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

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/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

@@ -135,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/edb.py

@@ -41,13 +41,13 @@ from zipfile import ZipFile as zpf
 import rtree
 
 from pyedb.configuration.configuration import Configuration
+import pyedb.dotnet
 from pyedb.dotnet.database.Variables import decompose_variable_value
 from pyedb.dotnet.database.cell.layout import Layout
 from pyedb.dotnet.database.cell.terminal.terminal import Terminal
 from pyedb.dotnet.database.components import Components
 import pyedb.dotnet.database.dotnet.database
 from pyedb.dotnet.database.dotnet.database import Database
-from pyedb.dotnet.database.edb_data.control_file import convert_technology_file
 from pyedb.dotnet.database.edb_data.design_options import EdbDesignOptions
 from pyedb.dotnet.database.edb_data.edbvalue import EdbValue
 from pyedb.dotnet.database.edb_data.ports import (
@@ -134,9 +134,17 @@ class Edb(Database):
         Reference to the AEDT project object.
     student_version : bool, optional
         Whether to open the AEDT student version. The default is ``False.``
+    control_file : str, optional
+            Path to the XML file. The default is ``None``, in which case an attempt is made to find
+            the XML file in the same directory as the board file. To succeed, the XML file and board file
+            must have the same name. Only the extension differs.
+    map_file : str, optional
+        Layer map .map file.
     technology_file : str, optional
         Full path to technology file to be converted to xml before importing or xml.
         Supported by GDS format only.
+    layer_filter:str,optional
+        Layer filter .txt file.
 
     Examples
     --------
@@ -182,7 +190,10 @@ class Edb(Database):
         oproject=None,
         student_version: bool = False,
         use_ppe: bool = False,
+        control_file: str = None,
+        map_file: str = None,
         technology_file: str = None,
+        layer_filter: str = None,
         remove_existing_aedt: bool = False,
     ):
         if isinstance(edbpath, Path):
@@ -232,27 +243,35 @@ class Edb(Database):
                 zipped_file.extractall(edbpath[:-4])
                 self.logger.info("ODB++ unzipped successfully.")
             zipped_file.close()
-            control_file = None
-            if technology_file:
-                if os.path.splitext(technology_file)[1] == ".xml":
-                    control_file = technology_file
-                else:
-                    control_file = convert_technology_file(technology_file, edbversion=edbversion)
             self.logger.info("Translating ODB++ to EDB...")
-            self.import_layout_file(edbpath[:-4], working_dir, use_ppe=use_ppe, control_file=control_file)
+            if not self.import_layout_file(
+                edbpath[:-4],
+                working_dir,
+                use_ppe=use_ppe,
+                control_file=control_file,
+                tech_file=technology_file,
+                layer_filter=layer_filter,
+                map_file=map_file,
+            ):
+                raise AttributeError("Translation was unsuccessful")
+                return False
             if settings.enable_local_log_file and self.log_name:
                 self._logger.add_file_logger(self.log_name, "Edb")
             self.logger.info("EDB %s was created correctly from %s file.", self.edbpath, edbpath)
         elif edbpath[-3:] in ["brd", "mcm", "sip", "gds", "xml", "dxf", "tgz", "anf"]:
             self.edbpath = edbpath[:-4] + ".aedb"
             working_dir = os.path.dirname(edbpath)
-            control_file = None
-            if technology_file:
-                if os.path.splitext(technology_file)[1] == ".xml":
-                    control_file = technology_file
-                else:
-                    control_file = convert_technology_file(technology_file, edbversion=edbversion)
-            self.import_layout_file(edbpath, working_dir, use_ppe=use_ppe, control_file=control_file)
+            if not self.import_layout_file(
+                edbpath,
+                working_dir,
+                use_ppe=use_ppe,
+                control_file=control_file,
+                tech_file=technology_file,
+                layer_filter=layer_filter,
+                map_file=map_file,
+            ):
+                raise AttributeError("Translation was unsuccessful")
+                return False
             if settings.enable_local_log_file and self.log_name:
                 self._logger.add_file_logger(self.log_name, "Edb")
             self.logger.info("EDB %s was created correctly from %s file.", self.edbpath, edbpath[-2:])
@@ -371,6 +390,11 @@ class Edb(Database):
         self._stackup2 = self._stackup
         self._materials = Materials(self)
 
+    @property
+    def pedb_class(self):
+        if not self.grpc:
+            return pyedb.dotnet
+
     @property
     def grpc(self):
         """grpc flag."""
@@ -584,7 +608,7 @@ class Edb(Database):
         #     self.standalone = False
 
         self.run_as_standalone(self.standalone)
-        self.create(self.edbpath)
+        self._db = self.create(self.edbpath)
         if not self.active_db:
             self.logger.warning("Error creating the database.")
             self._active_cell = None
@@ -733,8 +757,7 @@ class Edb(Database):
             cmd_translator.append('-t="{}"'.format(tech_file))
         if layer_filter:
             cmd_translator.append('-f="{}"'.format(layer_filter))
-        p = subprocess.Popen(cmd_translator)
-        p.wait()
+        subprocess.run(cmd_translator)
         if not os.path.exists(os.path.join(working_dir, aedb_name)):
             self.logger.error("Translator failed to translate.")
             return False

pyedb/grpc/database/components.py

@@ -178,8 +178,7 @@ class Components(object):
     @property
     def nport_comp_definition(self):
         """Retrieve Nport component definition list."""
-        m = "Ansys.Ansoft.Edb.Definition.NPortComponentModel"
-        return {name: l for name, l in self.definitions.items() if m in [i for i in l.model]}
+        return {name: l for name, l in self.definitions.items() if l.reference_file}
 
     def import_definition(self, file_path):
         """Import component definition from json file.

pyedb/grpc/database/definition/component_def.py

@@ -230,4 +230,4 @@ class ComponentDef(GrpcComponentDef):
         if pin_order:
             old = {i.name: i for i in self.component_pins}
             temp = [old[str(i)] for i in pin_order]
-            self.component_pins = temp
+            self.reorder_pins(temp)

pyedb/grpc/database/hfss.py

@@ -1240,6 +1240,12 @@ class Hfss(object):
         from ansys.edb.core.simulation_setup.hfss_simulation_setup import (
             HfssSimulationSetup as GrpcHfssSimulationSetup,
         )
+        from ansys.edb.core.simulation_setup.simulation_setup import (
+            Distribution as GrpcDistribution,
+        )
+        from ansys.edb.core.simulation_setup.simulation_setup import (
+            FrequencyData as GrpcFrequencyData,
+        )
         from ansys.edb.core.simulation_setup.simulation_setup import (
             SweepData as GrpcSweepData,
         )
@@ -1267,7 +1273,10 @@ class Hfss(object):
         sweep_name = f"sweep_{len(setup.sweep_data) + 1}"
         sweep_data = [
             GrpcSweepData(
-                name=sweep_name, distribution=distribution, start_f=start_freq, end_f=stop_freq, step=step_freq
+                name=sweep_name,
+                frequency_data=GrpcFrequencyData(
+                    distribution=GrpcDistribution[distribution], start_f=start_freq, end_f=stop_freq, step=step_freq
+                ),
             )
         ]
         if discrete_sweep:

pyedb/grpc/database/layout_validation.py

@@ -284,9 +284,9 @@ class LayoutValidation:
             if prim.net_name in net_list:
                 new_prims.extend(prim.fix_self_intersections())
         if new_prims:
-            self._pedb._logger.info("Self-intersections detected and removed.")
+            self._pedb.logger.info("Self-intersections detected and removed.")
         else:
-            self._pedb._logger.info("Self-intersection not found.")
+            self._pedb.logger.info("Self-intersection not found.")
         return True
 
     def illegal_net_names(self, fix=False):

pyedb/grpc/database/padstacks.py

@@ -1569,14 +1569,13 @@ class Padstacks(object):
         for id, inst in self.instances.items():
             instances_index[id] = inst.position
         for contour_box in contour_boxes:
-            all_instances = self.instances
             instances = self.get_padstack_instances_id_intersecting_polygon(
                 points=contour_box, padstack_instances_index=instances_index
             )
             if net_filter:
-                instances = [self.instances[id] for id in instances if not self.instances[id].net.name in net_filter]
+                instances = [id for id in instances if not self.instances[id].net.name in net_filter]
             net = self.instances[instances[0]].net.name
-            instances_pts = np.array([self.instances[id].position for id in instances])
+            instances_pts = np.array([self.instances[inst].position for inst in instances])
             convex_hull_contour = ConvexHull(instances_pts)
             contour_points = list(instances_pts[convex_hull_contour.vertices])
             layer = list(self._pedb.stackup.layers.values())[0].name
@@ -1595,9 +1594,15 @@ class Padstacks(object):
                 stop_layer=stop_layer,
             ):
                 self._logger.error(f"Failed to create padstack definition {new_padstack_def}")
-            merged_instance = self.place(position=[0, 0], definition_name=new_padstack_def, net_name=net)
-            merged_via_ids.append(merged_instance.id)
-            [self.instances[id].delete() for id in instances]
+            merged_instance = self.place(
+                position=[0, 0],
+                definition_name=new_padstack_def,
+                net_name=net,
+                fromlayer=start_layer,
+                tolayer=stop_layer,
+            )
+            merged_via_ids.append(merged_instance.edb_uid)
+            [self.instances[inst].delete() for inst in instances]
         return merged_via_ids
 
     def reduce_via_in_bounding_box(self, bounding_box, x_samples, y_samples, nets=None):
@@ -1611,7 +1616,7 @@ class Padstacks(object):
         x_samples : int
         y_samples : int
         nets : str or list, optional
-            net name of list of nets name applying filtering on padstack instances selection. If ``None`` is provided
+            net name of list of nets name applying filtering on pad-stack instances selection. If ``None`` is provided
             all instances are included in the index. Default value is ``None``.
 
         Returns
@@ -1622,10 +1627,11 @@ class Padstacks(object):
 
         padstacks_inbox = self.get_padstack_instances_intersecting_bounding_box(bounding_box, nets)
         if not padstacks_inbox:
-            raise "No pad-stack in bounding box."
+            return False
         else:
             if len(padstacks_inbox) <= (x_samples * y_samples):
-                raise f"more samples {x_samples * y_samples} than existing {len(padstacks_inbox)}"
+                self._pedb.logger.error(f"more samples {x_samples * y_samples} than existing {len(padstacks_inbox)}")
+                return False
             else:
                 # extract ids and positions
                 vias = {item: self.instances[item].position for item in padstacks_inbox}

pyedb/grpc/database/ports/ports.py

@@ -146,7 +146,7 @@ class WavePort(EdgeTerminal):
     """
 
     def __init__(self, pedb, edb_terminal):
-        super().__init__(pedb, edb_terminal.msg)
+        super().__init__(pedb, edb_terminal)
 
     @property
     def horizontal_extent_factor(self):
@@ -161,9 +161,9 @@ class WavePort(EdgeTerminal):
 
     @horizontal_extent_factor.setter
     def horizontal_extent_factor(self, value):
-        self.p = p
-        p = self.p
+        p = self._hfss_port_property
         p["Horizontal Extent Factor"] = value
+        self._hfss_port_property = p
 
     @property
     def vertical_extent_factor(self):

pyedb/grpc/database/simulation_setup/hfss_simulation_setup.py

@@ -367,18 +367,23 @@ class HfssSimulationSetup(GrpcHfssSimulationSetup):
             start_freq = self._pedb.number_with_units(start_freq, "Hz")
             stop_freq = self._pedb.number_with_units(stop_freq, "Hz")
             step = str(step)
-            if distribution.lower() == "linear":
-                distribution = "LIN"
-            elif distribution.lower() == "linear_count":
-                distribution = "LINC"
-            elif distribution.lower() == "exponential":
-                distribution = "ESTP"
-            elif distribution.lower() == "decade_count":
-                distribution = "DEC"
-            elif distribution.lower() == "octave_count":
-                distribution = "OCT"
-            else:
-                distribution = "LIN"
+            if not distribution in ["LIN", "LINC", "ESTP", "DEC", "OCT"]:
+                if distribution.lower() == "linear" or distribution.lower() == "linear scale":
+                    distribution = "LIN"
+                elif distribution.lower() == "linear_count" or distribution.lower() == "linear count":
+                    distribution = "LINC"
+                elif distribution.lower() == "exponential":
+                    distribution = "ESTP"
+                elif (
+                    distribution.lower() == "decade_count"
+                    or distribution.lower() == "decade count"
+                    or distribution.lower()
+                ) == "log scale":
+                    distribution = "DEC"
+                elif distribution.lower() == "octave_count" or distribution.lower() == "octave count":
+                    distribution = "OCT"
+                else:
+                    distribution = "LIN"
             if not name:
                 name = f"sweep_{init_sweep_count + 1}"
             sweep_data = [
@@ -392,7 +397,7 @@ class HfssSimulationSetup(GrpcHfssSimulationSetup):
                 sweep_data.append(sweep)
             self.sweep_data = sweep_data
             if len(self.sweep_data) == init_sweep_count + 1:
-                return True
+                return self.sweep_data[-1]
             else:
                 self._pedb.logger.error("Failed to add frequency sweep data")
                 return False

pyedb/grpc/database/simulation_setup/siwave_simulation_setup.py

@@ -57,7 +57,14 @@ class SiwaveSimulationSetup(GrpcSIWaveSimulationSetup):
             super(SiwaveSimulationSetup, self.__class__).type.__set__(self, GrpcSimulationSetupType.SI_WAVE_DCIR)
 
     def add_sweep(
-        self, name=None, distribution="linear", start_freq="0GHz", stop_freq="20GHz", step="10MHz", discrete=False
+        self,
+        name=None,
+        distribution="linear",
+        start_freq="0GHz",
+        stop_freq="20GHz",
+        step="10MHz",
+        discrete=False,
+        frequency_set=None,
     ):
         """Add a HFSS frequency sweep.
 
@@ -81,39 +88,75 @@ class SiwaveSimulationSetup(GrpcSIWaveSimulationSetup):
             distribution. Must be integer in that case.
         discrete : bool, optional
             Whether the sweep is discrete. The default is ``False``.
+        frequency_set : List, optional
+            Frequency set is a list adding one or more frequency sweeps. If ``frequency_set`` is provided, the other
+            arguments are ignored except ``discrete``. Default value is ``None``.
+            example of frequency_set : [['linear_scale', '50MHz', '200MHz', '10MHz']].
 
         Returns
         -------
         bool
         """
         init_sweep_count = len(self.sweep_data)
-        start_freq = self._pedb.number_with_units(start_freq, "Hz")
-        stop_freq = self._pedb.number_with_units(stop_freq, "Hz")
-        step = str(step)
-        if distribution.lower() == "linear":
-            distribution = "LIN"
-        elif distribution.lower() == "linear_count":
-            distribution = "LINC"
-        elif distribution.lower() == "exponential":
-            distribution = "ESTP"
-        elif distribution.lower() == "decade_count":
-            distribution = "DEC"
-        elif distribution.lower() == "octave_count":
-            distribution = "OCT"
+        if frequency_set:
+            for sweep in frequency_set:
+                if "linear_scale" in sweep:
+                    distribution = "LIN"
+                elif "linear_count" in sweep:
+                    distribution = "LINC"
+                elif "exponential" in sweep:
+                    distribution = "ESTP"
+                elif "log_scale" in sweep:
+                    distribution = "DEC"
+                elif "octave_count" in sweep:
+                    distribution = "OCT"
+                else:
+                    distribution = "LIN"
+                start_freq = self._pedb.number_with_units(sweep[1], "Hz")
+                stop_freq = self._pedb.number_with_units(sweep[2], "Hz")
+                step = str(sweep[3])
+                if not name:
+                    name = f"sweep_{init_sweep_count + 1}"
+                sweep_data = [
+                    SweepData(
+                        self._pedb, name=name, distribution=distribution, start_f=start_freq, end_f=stop_freq, step=step
+                    )
+                ]
+                if discrete:
+                    sweep_data[0].type = sweep_data[0].type.DISCRETE_SWEEP
+                for sweep in self.sweep_data:
+                    sweep_data.append(sweep)
+                self.sweep_data = sweep_data
         else:
-            distribution = "LIN"
-        if not name:
-            name = f"sweep_{init_sweep_count + 1}"
-        sweep_data = [
-            SweepData(self._pedb, name=name, distribution=distribution, start_f=start_freq, end_f=stop_freq, step=step)
-        ]
-        if discrete:
-            sweep_data[0].type = sweep_data[0].type.DISCRETE_SWEEP
-        for sweep in self.sweep_data:
-            sweep_data.append(sweep)
-        self.sweep_data = sweep_data
-        if len(self.sweep_data) == init_sweep_count + 1:
-            return True
-        else:
-            self._pedb.logger.error("Failed to add frequency sweep data")
-            return False
+            start_freq = self._pedb.number_with_units(start_freq, "Hz")
+            stop_freq = self._pedb.number_with_units(stop_freq, "Hz")
+            step = str(step)
+            if distribution.lower() == "linear":
+                distribution = "LIN"
+            elif distribution.lower() == "linear_count":
+                distribution = "LINC"
+            elif distribution.lower() == "exponential":
+                distribution = "ESTP"
+            elif distribution.lower() == "decade_count":
+                distribution = "DEC"
+            elif distribution.lower() == "octave_count":
+                distribution = "OCT"
+            else:
+                distribution = "LIN"
+            if not name:
+                name = f"sweep_{init_sweep_count + 1}"
+            sweep_data = [
+                SweepData(
+                    self._pedb, name=name, distribution=distribution, start_f=start_freq, end_f=stop_freq, step=step
+                )
+            ]
+            if discrete:
+                sweep_data[0].type = sweep_data[0].type.DISCRETE_SWEEP
+            for sweep in self.sweep_data:
+                sweep_data.append(sweep)
+            self.sweep_data = sweep_data
+            if len(self.sweep_data) == init_sweep_count + 1:
+                return True
+            else:
+                self._pedb.logger.error("Failed to add frequency sweep data")
+                return False

pyedb/grpc/database/simulation_setup/sweep_data.py

@@ -20,6 +20,12 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+from ansys.edb.core.simulation_setup.simulation_setup import (
+    Distribution as GrpcDistribution,
+)
+from ansys.edb.core.simulation_setup.simulation_setup import (
+    FrequencyData as GrpcFrequencyData,
+)
 from ansys.edb.core.simulation_setup.simulation_setup import SweepData as GrpcSweepData
 
 
@@ -27,6 +33,11 @@ class SweepData(GrpcSweepData):
     """Frequency sweep data class."""
 
     def __init__(self, pedb, name, distribution, start_f, end_f, step, edb_object=None):
-        super().__init__(name=name, distribution=distribution, start_f=start_f, end_f=end_f, step=step)
+        super().__init__(
+            name=name,
+            frequency_data=GrpcFrequencyData(
+                distribution=GrpcDistribution[distribution], start_f=start_f, end_f=end_f, step=step
+            ),
+        )
         self._edb_object = edb_object
         self._pedb = pedb

pyedb/grpc/database/siwave.py

@@ -28,6 +28,12 @@ import os
 import warnings
 
 from ansys.edb.core.database import ProductIdType as GrpcProductIdType
+from ansys.edb.core.simulation_setup.simulation_setup import (
+    Distribution as GrpcDistribution,
+)
+from ansys.edb.core.simulation_setup.simulation_setup import (
+    FrequencyData as GrpcFrequencyData,
+)
 from ansys.edb.core.simulation_setup.simulation_setup import SweepData as GrpcSweepData
 
 from pyedb.misc.siw_feature_config.xtalk_scan.scan_config import SiwaveScanConfig
@@ -592,7 +598,10 @@ class Siwave(object):
         sweep_name = f"sweep_{len(setup.sweep_data) + 1}"
         sweep_data = [
             GrpcSweepData(
-                name=sweep_name, distribution=distribution, start_f=start_freq, end_f=stop_freq, step=step_freq
+                name=sweep_name,
+                frequency_data=GrpcFrequencyData(
+                    distribution=GrpcDistribution[distribution], start_f=start_freq, end_f=stop_freq, step=step_freq
+                ),
             )
         ]
         if discrete_sweep:

pyedb/grpc/database/source_excitations.py

@@ -225,7 +225,7 @@ class SourceExcitation:
         if refdes and any(refdes.rlc_values):
             return self._pedb.components.deactivate_rlc_component(component=refdes, create_circuit_port=True)
         if not port_name:
-            port_name = f"Port_{pins[0].net_name}_{pins[0].name}"
+            port_name = f"Port_{pins[0].net_name}_{pins[0].component.name}_{pins[0].name}"
 
         if len(pins) > 1 or pingroup_on_single_pin:
             pec_boundary = False
@@ -713,9 +713,19 @@ class SourceExcitation:
         -------
         Edb pin group terminal.
         """
+        from ansys.edb.core.hierarchy.pin_group import PinGroup as GrpcPinGroup
+
+        from pyedb.grpc.database.hierarchy.pingroup import PinGroup
+
         if pingroup.is_null:
             self._logger.error(f"{pingroup} is null")
-        pin = PadstackInstance(self._pedb, pingroup.pins[0])
+        if not pingroup.pins:
+            self._pedb.logger.error("No pins defined on pingroup.")
+            return False
+        if isinstance(pingroup, GrpcPinGroup):
+            pingroup = PinGroup(self._pedb, pingroup)
+        pin = list(pingroup.pins.values())[0]
+        pin = PadstackInstance(self._pedb, pin)
         if term_name is None:
             term_name = f"{pin.component.name}.{pin.name}.{pin.net_name}"
         for t in self._pedb.active_layout.terminals: