pyedb 0.39.1__py3-none-any.whl → 0.40.0__py3-none-any.whl

pyedb/grpc/database/padstacks.py

@@ -45,6 +45,7 @@ from ansys.edb.core.definition.padstack_def_data import PadType as GrpcPadType
 from ansys.edb.core.geometry.point_data import PointData as GrpcPointData
 from ansys.edb.core.geometry.polygon_data import PolygonData as GrpcPolygonData
 from ansys.edb.core.utility.value import Value as GrpcValue
+import numpy as np
 import rtree
 
 from pyedb.generic.general_methods import generate_unique_name
@@ -824,13 +825,12 @@ class Padstacks(object):
         elif polygon_hole:
             if isinstance(polygon_hole, list):
                 polygon_hole = GrpcPolygonData(points=polygon_hole)
-
             padstack_data.set_hole_parameters(
                 offset_x=value0,
                 offset_y=value0,
                 rotation=value0,
                 type_geom=GrpcPadGeometryType.PADGEOMTYPE_POLYGON,
-                sizes=polygon_hole,
+                fp=polygon_hole,
             )
             padstack_data.plating_percentage = GrpcValue(20.0)
         else:
@@ -1329,27 +1329,61 @@ class Padstacks(object):
         else:
             instances = list(self.instances.values())
         for inst in instances:
-            padstack_instances_index.insert(inst.id, inst.position)
+            padstack_instances_index.insert(inst.edb_uid, inst.position)
         return padstack_instances_index
 
-    def get_padstack_instances_intersecting_bounding_box(self, bounding_box, nets=None):
+    def get_padstack_instances_id_intersecting_polygon(self, points, nets=None, padstack_instances_index=None):
         """Returns the list of padstack instances ID intersecting a given bounding box and nets.
 
         Parameters
         ----------
-        bounding_box : tuple or list.
+        points : tuple or list.
             bounding box, [x1, y1, x2, y2]
         nets : str or list, optional
             net name of list of nets name applying filtering on padstack instances selection. If ``None`` is provided
             all instances are included in the index. Default value is ``None``.
+        padstack_instances_index : optional, Rtree object.
+            Can be provided optionally to prevent computing padstack instances Rtree index again.
 
         Returns
         -------
+        List[int]
+            List of padstack instances ID intersecting the bounding box.
+        """
+        if not points:
+            raise Exception("No points defining polygon was provided")
+        if not padstack_instances_index:
+            padstack_instances_index = {}
+            for inst in self.instances:
+                padstack_instances_index[inst.id] = inst.position
+        _x = [pt[0] for pt in points]
+        _y = [pt[1] for pt in points]
+        points = [_x, _y]
+        return [
+            ind for ind, pt in padstack_instances_index.items() if GeometryOperators.is_point_in_polygon(pt, points)
+        ]
+
+    def get_padstack_instances_intersecting_bounding_box(self, bounding_box, nets=None, padstack_instances_index=None):
+        """Returns the list of padstack instances ID intersecting a given bounding box and nets.
+        Parameters
+        ----------
+        bounding_box : tuple or list.
+            bounding box, [x1, y1, x2, y2]
+        nets : str or list, optional
+            net name of list of nets name applying filtering on padstack instances selection. If ``None`` is provided
+            all instances are included in the index. Default value is ``None``.
+        padstack_instances_index : optional, Rtree object.
+            Can be provided optionally to prevent computing padstack instances Rtree index again.
+        Returns
+        -------
         List of padstack instances ID intersecting the bounding box.
         """
         if not bounding_box:
             raise Exception("No bounding box was provided")
-        index = self.get_padstack_instances_rtree_index(nets=nets)
+        if not padstack_instances_index:
+            index = self.get_padstack_instances_rtree_index(nets=nets)
+        else:
+            index = padstack_instances_index
         if not len(bounding_box) == 4:
             raise Exception("The bounding box length must be equal to 4")
         if isinstance(bounding_box, list):
@@ -1357,18 +1391,23 @@ class Padstacks(object):
         return list(index.intersection(bounding_box))
 
     def merge_via_along_lines(
-        self, net_name="GND", distance_threshold=5e-3, minimum_via_number=6, selected_angles=None
+        self,
+        net_name="GND",
+        distance_threshold=5e-3,
+        minimum_via_number=6,
+        selected_angles=None,
+        padstack_instances_id=None,
     ):
         """Replace padstack instances along lines into a single polygon.
 
-        Detect all padstack instances that are placed along lines and replace them by a single polygon based one
+        Detect all pad-stack instances that are placed along lines and replace them by a single polygon based one
         forming a wall shape. This method is designed to simplify meshing on via fence usually added to shield RF traces
         on PCB.
 
         Parameters
         ----------
         net_name : str
-            Net name used for detected padstack instances. Default value is ``"GND"``.
+            Net name used for detected pad-stack instances. Default value is ``"GND"``.
 
         distance_threshold : float, None, optional
             If two points in a line are separated by a distance larger than `distance_threshold`,
@@ -1382,22 +1421,29 @@ class Padstacks(object):
             Other values can be assigned like 45 degrees. When `None` is provided all lines are detected. Default value
             is `None`.
 
+        padstack_instances_id : List[int]
+            List of pad-stack instances ID's to include. If `None`, the algorithm will scan all pad-stack
+            instances belonging to the specified net. Default value is `None`.
+
         Returns
         -------
-        bool
-            ``True`` when succeeded ``False`` when failed. <
+        List[int], list of created pad-stack instances id.
 
         """
         _def = list(set([inst.padstack_def for inst in list(self.instances.values()) if inst.net_name == net_name]))
         if not _def:
             self._logger.error(f"No padstack definition found for net {net_name}")
             return False
+        instances_created = []
         _instances_to_delete = []
         padstack_instances = []
-        for pdstk_def in _def:
-            padstack_instances.append(
-                [inst for inst in self.definitions[pdstk_def.name].instances if inst.net_name == net_name]
-            )
+        if padstack_instances_id:
+            padstack_instances = [[self.instances[id] for id in padstack_instances_id]]
+        else:
+            for pdstk_def in _def:
+                padstack_instances.append(
+                    [inst for inst in self.definitions[pdstk_def.name].instances if inst.net_name == net_name]
+                )
         for pdstk_series in padstack_instances:
             instances_location = [inst.position for inst in pdstk_series]
             lines, line_indexes = GeometryOperators.find_points_along_lines(
@@ -1431,44 +1477,99 @@ class Padstacks(object):
                     polygon_hole=polygon_data,
                 ):
                     self._logger.error(f"Failed to create padstack definition {new_padstack_def.name}")
-                if not self.place(position=[0, 0], definition_name=new_padstack_def, net_name=net_name):
-                    self._logger.error(f"Failed to place padstack instance {new_padstack_def.name}")
+                new_instance = self.place(position=[0, 0], definition_name=new_padstack_def, net_name=net_name)
+                if not new_instance:
+                    self._logger.error(f"Failed to place padstack instance {new_padstack_def}")
+                else:
+                    instances_created.append(new_instance.id)
             for inst in _instances_to_delete:
                 inst.delete()
-        return True
+        return instances_created
+
+    def reduce_via_in_bounding_box(self, bounding_box, x_samples, y_samples, nets=None):
+        """Reduces the number of vias intersecting bounding box and nets by x and y samples.
+
+        Parameters
+        ----------
+        bounding_box : tuple or list.
+            bounding box, [x1, y1, x2, y2]
+        x_samples : int
+        y_samples : int
+        nets : str or list, optional
+            net name or list of nets name applying filtering on padstack instances selection. If ``None`` is provided
+            all instances are included in the index. Default value is ``None``.
+
+        Returns
+        -------
+        bool
+            ``True`` when succeeded ``False`` when failed.
+        """
+
+        padstacks_inbox = self.get_padstack_instances_intersecting_bounding_box(bounding_box, nets)
+        if not padstacks_inbox:
+            self._logger.info("no padstack in bounding box")
+            return False
+        else:
+            if len(padstacks_inbox) <= (x_samples * y_samples):
+                self._logger.info(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}
+                ids, positions = zip(*vias.items())
+                pt_x, pt_y = zip(*positions)
+
+                # meshgrid
+                _x_min, _x_max = min(pt_x), max(pt_x)
+                _y_min, _y_max = min(pt_y), max(pt_y)
+
+                x_grid, y_grid = np.meshgrid(
+                    np.linspace(_x_min, _x_max, x_samples), np.linspace(_y_min, _y_max, y_samples)
+                )
+
+                # mapping to meshgrid
+                to_keep = {
+                    ids[np.argmin(np.square(_x - pt_x) + np.square(_y - pt_y))]
+                    for _x, _y in zip(x_grid.ravel(), y_grid.ravel())
+                }
+
+                for item in padstacks_inbox:
+                    if item not in to_keep:
+                        self.instances[item].delete()
+
+                return True
 
     def merge_via(self, contour_boxes, net_filter=None, start_layer=None, stop_layer=None):
-        """Evaluate padstack instances included on the provided point list and replace all by single instance.
+        """Evaluate pad-stack instances included on the provided point list and replace all by single instance.
 
         Parameters
         ----------
         contour_boxes : List[List[List[float, float]]]
             Nested list of polygon with points [x,y].
         net_filter : optional
-            List[str: net_name] apply a net filter,
-            nets included in the filter are excluded from the via merge.
+            List[str: net_name] apply a net filter, nets included in the filter are excluded from the via merge.
         start_layer : optional, str
-            Padstack instance start layer, if `None` the top layer is selected.
+            Pad-stack instance start layer, if `None` the top layer is selected.
         stop_layer : optional, str
-            Padstack instance stop layer, if `None` the bottom layer is selected.
+            Pad-stack instance stop layer, if `None` the bottom layer is selected.
 
         Return
         ------
-        List[str], list of created padstack instances ID.
+        List[str], list of created pad-stack instances ID.
 
         """
+
+        import numpy as np
+        from scipy.spatial import ConvexHull
+
         merged_via_ids = []
         if not contour_boxes:
-            self._pedb.logger.error("No contour box provided, you need to pass a nested list as argument.")
-            return False
-        if not start_layer:
-            start_layer = list(self._pedb.stackup.layers.values())[0].name
-        if not stop_layer:
-            stop_layer = list(self._pedb.stackup.layers.values())[-1].name
+            raise Exception("No contour box provided, you need to pass a nested list as argument.")
         instances_index = {}
         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
             )
@@ -1479,7 +1580,7 @@ class Padstacks(object):
             convex_hull_contour = ConvexHull(instances_pts)
             contour_points = list(instances_pts[convex_hull_contour.vertices])
             layer = list(self._pedb.stackup.layers.values())[0].name
-            polygon = self._pedb.modeler.create_polygon(main_shape=contour_points, layer_name=layer)
+            polygon = self._pedb.modeler.create_polygon(points=contour_points, layer_name=layer)
             polygon_data = polygon.polygon_data
             polygon.delete()
             new_padstack_def = generate_unique_name("test")
@@ -1498,3 +1599,55 @@ class Padstacks(object):
             merged_via_ids.append(merged_instance.id)
             [self.instances[id].delete() for id in instances]
         return merged_via_ids
+
+    def reduce_via_in_bounding_box(self, bounding_box, x_samples, y_samples, nets=None):
+        """
+        reduce the number of vias intersecting bounding box and nets by x and y samples.
+
+        Parameters
+        ----------
+        bounding_box : tuple or list.
+            bounding box, [x1, y1, x2, y2]
+        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
+            all instances are included in the index. Default value is ``None``.
+
+        Returns
+        -------
+        bool
+            ``True`` when succeeded ``False`` when failed.
+        """
+
+        padstacks_inbox = self.get_padstack_instances_intersecting_bounding_box(bounding_box, nets)
+        if not padstacks_inbox:
+            raise "No pad-stack in bounding box."
+        else:
+            if len(padstacks_inbox) <= (x_samples * y_samples):
+                raise f"more samples {x_samples * y_samples} than existing {len(padstacks_inbox)}"
+            else:
+                # extract ids and positions
+                vias = {item: self.instances[item].position for item in padstacks_inbox}
+                ids, positions = zip(*vias.items())
+                pt_x, pt_y = zip(*positions)
+
+                # meshgrid
+                _x_min, _x_max = min(pt_x), max(pt_x)
+                _y_min, _y_max = min(pt_y), max(pt_y)
+
+                x_grid, y_grid = np.meshgrid(
+                    np.linspace(_x_min, _x_max, x_samples), np.linspace(_y_min, _y_max, y_samples)
+                )
+
+                # mapping to meshgrid
+                to_keep = {
+                    ids[np.argmin(np.square(_x - pt_x) + np.square(_y - pt_y))]
+                    for _x, _y in zip(x_grid.ravel(), y_grid.ravel())
+                }
+
+                all_instances = self.instances
+                for item in padstacks_inbox:
+                    if item not in to_keep:
+                        all_instances[item].delete()
+                return True

pyedb/grpc/database/primitive/padstack_instance.py

@@ -399,7 +399,7 @@ class PadstackInstance(GrpcPadstackInstance):
         layer_list = []
         start_layer_name = start_layer.name
         stop_layer_name = stop_layer.name
-        for layer_name in list(self._pedb.stackup.layers.keys()):
+        for layer_name in list(self._pedb.stackup.signal_layers.keys()):
             if started:
                 layer_list.append(layer_name)
                 if layer_name == stop_layer_name or layer_name == start_layer_name:

pyedb/grpc/database/source_excitations.py

@@ -20,12 +20,11 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+from typing import Union
+
 from ansys.edb.core.database import ProductIdType as GrpcProductIdType
 from ansys.edb.core.geometry.point_data import PointData as GrpcPointData
 from ansys.edb.core.geometry.polygon_data import PolygonData as GrpcPolygonData
-from ansys.edb.core.hierarchy.component_group import (
-    ComponentGroup as GrpcComponentGroup,
-)
 from ansys.edb.core.terminal.terminals import BoundaryType as GrpcBoundaryType
 from ansys.edb.core.terminal.terminals import EdgeTerminal as GrpcEdgeTerminal
 from ansys.edb.core.terminal.terminals import PrimitiveEdge as GrpcPrimitiveEdge
@@ -33,6 +32,7 @@ from ansys.edb.core.utility.rlc import Rlc as GrpcRlc
 from ansys.edb.core.utility.value import Value as GrpcValue
 
 from pyedb.generic.general_methods import generate_unique_name
+from pyedb.grpc.database.components import Component
 from pyedb.grpc.database.layers.stackup_layer import StackupLayer
 from pyedb.grpc.database.net.net import Net
 from pyedb.grpc.database.ports.ports import BundleWavePort, WavePort
@@ -169,17 +169,18 @@ class SourceExcitation:
         Parameters
         ----------
         refdes : Component reference designator
-            str or EDBComponent object.
-        pins : pin name where the terminal has to be created. Single pin or several ones can be provided.If several
-        pins are provided a pin group will is created. Pin names can be the EDB name or the EDBPadstackInstance one.
-        For instance the pin called ``Pin1`` located on component ``U1``, ``U1-Pin1`` or ``Pin1`` can be provided and
-        will be handled.
-            str, [str], EDBPadstackInstance, [EDBPadstackInstance]
-        reference_pins : reference pin name used for terminal reference. Single pin or several ones can be provided.
-        If several pins are provided a pin group will is created. Pin names can be the EDB name or the
-        EDBPadstackInstance one. For instance the pin called ``Pin1`` located on component ``U1``, ``U1-Pin1``
-        or ``Pin1`` can be provided and will be handled.
-            str, [str], EDBPadstackInstance, [EDBPadstackInstance]
+            str or Component object.
+        pins : pin specifier(s) or instance(s) where the port terminal is to be created. Single pin name or a list of
+        several can be provided. If several pins are provided a pin group will be created. Pin specifiers can be the
+        global EDB object ID or padstack instance name or pin name on component with refdes ``refdes``. Pin instances
+        can be provided as ``EDBPadstackInstance`` objects.
+        For instance for the pin called ``Pin1`` located on component with refdes ``U1``: ``U1-Pin1``, ``Pin1`` with
+        ``refdes=U1``, the pin's global EDB object ID, or the ``EDBPadstackInstance`` corresponding to the pin can be
+        provided.
+            Union[int, str, PadstackInstance], List[Union[int, str, PadstackInstance]]
+        reference_pins : reference pin specifier(s) or instance(s) for the port reference terminal. Allowed values are
+        the same as for the ``pins`` parameter.
+            Union[int, str, PadstackInstance], List[Union[int, str, PadstackInstance]]
         impedance : Port impedance
             str, float
         port_name : str, optional
@@ -208,116 +209,51 @@ class SourceExcitation:
         >>> edb.save_edb()
         >>> edb.close_edb()
         """
-        from pyedb.grpc.database.components import Component
 
-        if isinstance(pins, str):
-            pins = [pins]
-        elif isinstance(pins, PadstackInstance):
-            pins = [pins.name]
-        if not reference_pins:
-            self._logger.error("No reference pin provided.")
-            return False
-        if isinstance(reference_pins, str):
-            reference_pins = [reference_pins]
-        elif isinstance(reference_pins, int):
-            reference_pins = [reference_pins]
-        elif isinstance(reference_pins, PadstackInstance):
-            reference_pins = [reference_pins]
-        if isinstance(reference_pins, list):
-            _temp = []
-            for ref_pin in reference_pins:
-                if isinstance(ref_pin, int):
-                    pins = self._pedb.padstacks.instances
-                    reference_pins = [pins[ref_pin] for ref_pin in reference_pins if ref_pin in pins]
-                    # if reference_pins in pins:
-                    #     reference_pins = pins[reference_pins]
-                elif isinstance(ref_pin, str):
-                    component_pins = self._pedb.components.instances[refdes].pins
-                    if ref_pin in component_pins:
-                        _temp.append(component_pins[ref_pin])
-                    else:
-                        p = [pp for pp in list(self._pedb.padstack.instances.values()) if pp.name == ref_pin]
-                        if p:
-                            _temp.extend(p)
-                elif isinstance(ref_pin, PadstackInstance):
-                    _temp.append(ref_pin)
-            reference_pins = _temp
         if isinstance(refdes, str):
             refdes = self._pedb.components.instances[refdes]
-        elif isinstance(refdes, GrpcComponentGroup):
+        elif isinstance(refdes, Component):
             refdes = Component(self._pedb, refdes)
-        refdes_pins = refdes.pins
-        if any(refdes.rlc_values):
-            return self._pedb.components.deactivate_rlc_component(component=refdes, create_circuit_port=True)
-        if len([pin for pin in pins if isinstance(pin, str)]) == len(pins):
-            cmp_pins = []
-            for pin_name in pins:
-                cmp_pins = [pin for pin in list(refdes_pins.values()) if pin_name == pin.name]
-                if not cmp_pins:
-                    for pin in list(refdes_pins.values()):
-                        if pin.name and "-" in pin.name:
-                            if pin_name == pin.name.split("-")[1]:
-                                cmp_pins.append(pin)
-            if not cmp_pins:
-                self._logger.warning("No pin found during port creation. Port is not defined.")
-                return
-            pins = cmp_pins
-        if not len([pin for pin in pins if isinstance(pin, PadstackInstance)]) == len(pins):
-            self._logger.error("Pin list must contain only pins instances")
+        pins = self._get_pins_for_ports(pins, refdes)
+        if not pins:
+            self._logger.error("No pins found during port creation. Port is not defined.")
             return False
-        if not port_name:
-            pin = pins[0]
-            if pin.net.is_null:
-                pin_net_name = "no_net"
-            else:
-                pin_net_name = pin.net.name
-            port_name = f"Port_{pin_net_name}_{refdes.name}_{pins[0].name}"
-
-        ref_cmp_pins = []
-        for ref_pin in reference_pins:
-            if ref_pin.name in refdes_pins:
-                ref_cmp_pins.append(ref_pin)
-            elif "-" in ref_pin.name:
-                if ref_pin.name.split("-")[1] in refdes_pins:
-                    ref_cmp_pins.append(ref_pin)
-            elif "via" in ref_pin.name:
-                _ref_pin = [
-                    pin for pin in list(self._pedb.padstacks.instances.values()) if pin.aedt_name == ref_pin.name
-                ]
-                if _ref_pin:
-                    _ref_pin[0].is_layout_pin = True
-                    ref_cmp_pins.append(_ref_pin[0])
-        if not ref_cmp_pins:
-            self._logger.error("No reference pins found.")
+        reference_pins = self._get_pins_for_ports(reference_pins, refdes)
+        if not reference_pins:
+            self._logger.error("No reference pins found during port creation. Port is not defined.")
             return False
-        reference_pins = ref_cmp_pins
+        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}"
+
         if len(pins) > 1 or pingroup_on_single_pin:
             pec_boundary = False
             self._logger.info(
                 "Disabling PEC boundary creation, this feature is supported on single pin "
-                "ports only, {} pins found".format(len(pins))
+                f"ports only, {len(pins)} pins found (pingroup_on_single_pin: {pingroup_on_single_pin})."
             )
-            group_name = "group_{}".format(port_name)
+            group_name = f"group_{port_name}"
             pin_group = self._pedb.components.create_pingroup_from_pins(pins, group_name)
             term = self._create_pin_group_terminal(pingroup=pin_group, term_name=port_name)
-
         else:
             term = self._create_terminal(pins[0], term_name=port_name)
         term.is_circuit_port = True
+
         if len(reference_pins) > 1 or pingroup_on_single_pin:
             pec_boundary = False
             self._logger.info(
-                "Disabling PEC boundary creation. This feature is supported on single pin"
-                "ports only {} reference pins found.".format(len(reference_pins))
+                "Disabling PEC boundary creation. This feature is supported on single pin "
+                f"ports only, {len(reference_pins)} reference pins found "
+                f"(pingroup_on_single_pin: {pingroup_on_single_pin})."
             )
-            ref_group_name = "group_{}_ref".format(port_name)
+            ref_group_name = f"group_{port_name}_ref"
             ref_pin_group = self._pedb.components.create_pingroup_from_pins(reference_pins, ref_group_name)
-            ref_pin_group = self._pedb.siwave.pin_groups[ref_pin_group.name]
             ref_term = self._create_pin_group_terminal(pingroup=ref_pin_group, term_name=port_name + "_ref")
-
         else:
             ref_term = self._create_terminal(reference_pins[0], term_name=port_name + "_ref")
         ref_term.is_circuit_port = True
+
         term.impedance = GrpcValue(impedance)
         term.reference_terminal = ref_term
         if pec_boundary:
@@ -326,11 +262,33 @@ class SourceExcitation:
             term.boundary_type = GrpcBoundaryType.PEC
             ref_term.boundary_type = GrpcBoundaryType.PEC
             self._logger.info(
-                "PEC boundary created between pin {} and reference pin {}".format(pins[0].name, reference_pins[0].name)
+                f"PEC boundary created between pin {pins[0].name} and reference pin {reference_pins[0].name}"
             )
-        if term:
-            return term
-        return False
+        return term or False
+
+    def _get_pins_for_ports(
+        self, pins: Union[int, str, PadstackInstance, list[Union[int, str, PadstackInstance]]], comp: Component
+    ) -> list[PadstackInstance]:
+        if not isinstance(pins, list):
+            pins = [pins]
+        result = []
+        for pin in pins:
+            if isinstance(pin, int) and pin in self._pedb.padstacks.instances:
+                result.append(self._pedb.padstacks.instances[pin])
+            elif isinstance(pin, str):
+                if comp and pin in comp.pins:
+                    result.append(comp.pins[pin])
+                else:
+                    p = [
+                        pp
+                        for pp in list(self._pedb.padstacks.instances.values())
+                        if pp.name == pin or pp.aedt_name == pin
+                    ]
+                    if p:
+                        result.append(p[0])
+            elif isinstance(pin, PadstackInstance):
+                result.append(pin)
+        return result
 
     def create_port_on_component(
         self,
@@ -407,8 +365,14 @@ class SourceExcitation:
                         net_list.append(net_name)
                 except:
                     pass
-        if reference_net in net_list:
-            net_list.remove(reference_net)
+        if isinstance(reference_net, str) or isinstance(reference_net, Net):
+            reference_net = [reference_net]
+        _reference_net = [ref.name for ref in reference_net if isinstance(ref, Net)]
+        if len(_reference_net) == len(reference_net):
+            reference_net = _reference_net
+        for ref_net in reference_net:
+            if ref_net in net_list:
+                net_list.remove(ref_net)
         cmp_pins = [p for p in list(component.pins.values()) if p.net_name in net_list]
         for p in cmp_pins:  # pragma no cover
             p.is_layout_pin = True
@@ -541,6 +505,20 @@ class SourceExcitation:
                                 self._logger.error("Skipping port creation no reference pin found.")
         return True
 
+    @staticmethod
+    def _normalize_net_list(net_list) -> set[str]:
+        if not isinstance(net_list, list):
+            net_list = [net_list]
+        nets = set()
+        for net in net_list:
+            if isinstance(net, Net):
+                net_name = net.name
+                if net_name != "":
+                    nets.add(net_name)
+            elif isinstance(net, str) and net != "":
+                nets.add(net)
+        return nets
+
     def _create_terminal(self, pin, term_name=None):
         """Create terminal on component pin.