pyedb 0.19.0__py3-none-any.whl → 0.21.0__py3-none-any.whl

pyedb/dotnet/edb_core/cell/voltage_regulator.py

@@ -20,7 +20,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-from pyedb.dotnet.edb_core.cell.layout_obj import Connectable
+from pyedb.dotnet.edb_core.cell.connectable import Connectable
 from pyedb.dotnet.edb_core.edb_data.padstacks_data import EDBPadstackInstance
 
 
@@ -49,7 +49,7 @@ class VoltageRegulator(Connectable):
         if value not in self._pedb.components.instances:
             self._pedb.logger.error(f"component {value} not found in layout")
             return
-        self._edb_object.SetGroup(self._pedb.components.instances[value].edbcomponent)
+        self._edb_object.SetGroup(self._pedb.components.instances[value]._edb_object)
 
     @property
     def load_regulator_current(self):
@@ -71,16 +71,6 @@ class VoltageRegulator(Connectable):
         _value = self._edb_object.edb_value(value)
         self._edb_object.SetLoadRegulationPercent(_value)
 
-    @property
-    def name(self):
-        """Retrieve voltage regulator name."""
-        return self._edb_object.GetName()
-
-    @name.setter
-    def name(self, value):
-        if isinstance(value, str):
-            self._edb_object.SetName(value)
-
     @property
     def negative_remote_sense_pin(self):
         """Retrieve negative remote sense pin."""
@@ -137,7 +127,3 @@ class VoltageRegulator(Connectable):
     def is_active(self, value):
         if isinstance(value, bool):
             self._edb_object.SetIsActive(value)
-
-    @property
-    def is_null(self):
-        return self._edb_object.IsNull()

pyedb/dotnet/edb_core/components.py

@@ -305,11 +305,10 @@ class Components(object):
     def refresh_components(self):
         """Refresh the component dictionary."""
         # self._logger.info("Refreshing the Components dictionary.")
-        self._cmp = {
-            l.GetName(): EDBComponent(self._pedb, l)
-            for l in self._layout.groups
-            if l.ToString() == "Ansys.Ansoft.Edb.Cell.Hierarchy.Component"
-        }
+        self._cmp = {}
+        for i in self._pedb.layout.groups:
+            if i.group_type == "component":
+                self._cmp[i.name] = i
         return True
 
     @property
@@ -487,11 +486,7 @@ class Components(object):
             ``True`` when successful, ``False`` when failed.
 
         """
-        edbcmp = self._pedb.edb_api.cell.hierarchy.component.FindByName(self._active_layout, name)
-        if edbcmp is not None:
-            return edbcmp
-        else:
-            pass
+        return self._pedb.layout.find_component_by_name(name)
 
     def get_components_from_nets(self, netlist=None):
         """Retrieve components from a net list.
@@ -675,9 +670,11 @@ class Components(object):
             positive_pin_group = self.create_pingroup_from_pins(positive_pins)
             if not positive_pin_group:  # pragma: no cover
                 return False
+            positive_pin_group = self._pedb.siwave.pin_groups[positive_pin_group.GetName()]
             negative_pin_group = self.create_pingroup_from_pins(negative_pins)
             if not negative_pin_group:  # pragma: no cover
                 return False
+            negative_pin_group = self._pedb.siwave.pin_groups[negative_pin_group.GetName()]
             if source.source_type == SourceType.Vsource:  # pragma: no cover
                 positive_pin_group_term = self._create_pin_group_terminal(
                     positive_pin_group,
@@ -848,7 +845,9 @@ class Components(object):
             )
             ref_group_name = "group_{}_ref".format(port_name)
             ref_pin_group = self.create_pingroup_from_pins(reference_pins, ref_group_name)
+            ref_pin_group = self._pedb.siwave.pin_groups[ref_pin_group.GetName()]
             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].primitive_object, term_name=port_name + "_ref")
         ref_term.SetIsCircuitPort(True)
@@ -1031,6 +1030,7 @@ class Components(object):
                     if not ref_pin_group:
                         self._logger.error(f"Failed to create reference pin group on component {component.GetName()}.")
                         return False
+                    ref_pin_group = self._pedb.siwave.pin_groups[ref_pin_group.GetName()]
                     ref_pin_group_term = self._create_pin_group_terminal(ref_pin_group, isref=False)
                     if not ref_pin_group_term:
                         self._logger.error(
@@ -1048,6 +1048,7 @@ class Components(object):
                             pin_group = self.create_pingroup_from_pins(pins)
                             if not pin_group:
                                 return False
+                            pin_group = self._pedb.siwave.pin_groups[pin_group.GetName()]
                             pin_group_term = self._create_pin_group_terminal(pin_group)
                             if pin_group_term:
                                 pin_group_term.SetReferenceTerminal(ref_pin_group_term)
@@ -1390,14 +1391,14 @@ class Components(object):
         -------
         Edb pin group terminal.
         """
-        pin = list(pingroup.GetPins())[0]
+        pin = list(pingroup._edb_object.GetPins())[0]
         if term_name is None:
             term_name = "{}.{}.{}".format(pin.GetComponent().GetName(), pin.GetName(), pin.GetNet().GetName())
         for t in list(self._pedb.active_layout.Terminals):
             if t.GetName() == term_name:
                 return t
         pingroup_term = self._edb.cell.terminal.PinGroupTerminal.Create(
-            self._active_layout, pingroup.GetNet(), term_name, pingroup, isref
+            self._active_layout, pingroup._edb_object.GetNet(), term_name, pingroup._edb_object, isref
         )
         if term_type == "circuit":
             pingroup_term.SetIsCircuitPort(True)
@@ -1985,7 +1986,7 @@ class Components(object):
 
         """
         if not isinstance(component, self._pedb.edb_api.cell.hierarchy.component):
-            edb_cmp = self.get_component_by_name(component)
+            edb_cmp = self.get_component_by_name(component)._edb_object
             cmp = self.instances[component]
         else:  # pragma: no cover
             edb_cmp = component

pyedb/dotnet/edb_core/dotnet/database.py

@@ -32,7 +32,6 @@ from pyedb.generic.general_methods import (
     env_path,
     env_path_student,
     env_value,
-    is_ironpython,
     is_linux,
     settings,
 )
@@ -751,14 +750,10 @@ class EdbDotNet(object):
                         self.base_path = edb_path
                         sys.path.append(edb_path)
                         os.environ[env_value(self.edbversion)] = self.base_path
-            if is_ironpython:
-                _clr.AddReferenceToFile("Ansys.Ansoft.Edb.dll")
-                _clr.AddReferenceToFile("Ansys.Ansoft.EdbBuilderUtils.dll")
-                _clr.AddReferenceToFileAndPath(os.path.join(self.base_path, "Ansys.Ansoft.SimSetupData.dll"))
-            else:
-                _clr.AddReference("Ansys.Ansoft.Edb")
-                _clr.AddReference("Ansys.Ansoft.EdbBuilderUtils")
-                _clr.AddReference("Ansys.Ansoft.SimSetupData")
+
+            _clr.AddReference("Ansys.Ansoft.Edb")
+            _clr.AddReference("Ansys.Ansoft.EdbBuilderUtils")
+            _clr.AddReference("Ansys.Ansoft.SimSetupData")
         else:
             if settings.edb_dll_path:
                 self.base_path = settings.edb_dll_path
@@ -1234,7 +1229,7 @@ class Database(EdbDotNet):
         -------
 
         """
-        from pyedb.generic.clr_module import Convert
+        from pyedb.dotnet.clr_module import Convert
 
         hdl = Convert.ToUInt64(hdb)
         self._db = self.edb_api.database.Attach(hdl)

pyedb/dotnet/edb_core/dotnet/primitive.py

@@ -96,7 +96,17 @@ class PrimitiveDotNet:
         _, name = self.prim_obj.GetProductProperty(self._app._edb.ProductId.Designer, 1, val)
         name = str(name).strip("'")
         if name == "":
-            name = "{}__{}".format(self.primitive_type, self.id)
+            if str(self.primitive_type) == "Path":
+                ptype = "line"
+            elif str(self.primitive_type) == "Rectangle":
+                ptype = "rect"
+            elif str(self.primitive_type) == "Polygon":
+                ptype = "poly"
+            elif str(self.primitive_type) == "Bondwire":
+                ptype = "bwr"
+            else:
+                ptype = str(self.primitive_type).lower()
+            name = "{}_{}".format(ptype, self.id)
             self.prim_obj.SetProductProperty(self._app._edb.ProductId.Designer, 1, name)
         return name
 

pyedb/dotnet/edb_core/edb_data/control_file.py

@@ -23,24 +23,14 @@
 import copy
 import os
 import re
+import subprocess
 import sys
 
 from pyedb.edb_logger import pyedb_logger
-from pyedb.generic.general_methods import (
-    ET,
-    env_path,
-    env_value,
-    is_ironpython,
-    is_linux,
-)
+from pyedb.generic.general_methods import ET, env_path, env_value, is_linux
 from pyedb.misc.aedtlib_personalib_install import write_pretty_xml
 from pyedb.misc.misc import list_installed_ansysem
 
-if is_linux and is_ironpython:
-    import subprocessdotnet as subprocess
-else:
-    import subprocess
-
 
 def convert_technology_file(tech_file, edbversion=None, control_file=None):
     """Convert a technology file to edb control file (xml).

pyedb/dotnet/edb_core/edb_data/padstacks_data.py

@@ -25,12 +25,12 @@ import math
 import re
 import warnings
 
-from pyedb.dotnet.clr_module import String, _clr
+from pyedb.dotnet.clr_module import String
 from pyedb.dotnet.edb_core.cell.primitive import Primitive
 from pyedb.dotnet.edb_core.dotnet.database import PolygonDataDotNet
 from pyedb.dotnet.edb_core.edb_data.edbvalue import EdbValue
 from pyedb.dotnet.edb_core.general import PadGeometryTpe, convert_py_list_to_net_list
-from pyedb.generic.general_methods import generate_unique_name, is_ironpython
+from pyedb.generic.general_methods import generate_unique_name
 from pyedb.modeler.geometry_operators import GeometryOperators
 
 
@@ -1403,17 +1403,12 @@ class EDBPadstackInstance(Primitive):
         layer = self._pedb.edb_api.cell.layer("", self._pedb.edb_api.cell.layer_type.SignalLayer)
         val = self._pedb.edb_value(0)
         offset = self._pedb.edb_value(0.0)
-        if is_ironpython:  # pragma: no cover
-            diameter = _clr.StrongBox[type(val)]()
-            drill_to_layer = _clr.StrongBox[self._pedb.edb_api.Cell.ILayerReadOnly]()
-            flag = self._edb_padstackinstance.GetBackDrillParametersLayerValue(drill_to_layer, offset, diameter, False)
-        else:
-            (
-                flag,
-                drill_to_layer,
-                offset,
-                diameter,
-            ) = self._edb_padstackinstance.GetBackDrillParametersLayerValue(layer, offset, val, False)
+        (
+            flag,
+            drill_to_layer,
+            offset,
+            diameter,
+        ) = self._edb_padstackinstance.GetBackDrillParametersLayerValue(layer, offset, val, False)
         if flag:
             if offset.ToDouble():
                 return drill_to_layer.GetName(), diameter.ToString(), offset.ToString()
@@ -1461,17 +1456,12 @@ class EDBPadstackInstance(Primitive):
         layer = self._pedb.edb_api.cell.layer("", self._pedb.edb_api.cell.layer_type.SignalLayer)
         val = self._pedb.edb_value(0)
         offset = self._pedb.edb_value(0.0)
-        if is_ironpython:  # pragma: no cover
-            diameter = _clr.StrongBox[type(val)]()
-            drill_to_layer = _clr.StrongBox[self._pedb.edb_api.Cell.ILayerReadOnly]()
-            flag = self._edb_padstackinstance.GetBackDrillParametersLayerValue(drill_to_layer, offset, diameter, True)
-        else:
-            (
-                flag,
-                drill_to_layer,
-                offset,
-                diameter,
-            ) = self._edb_padstackinstance.GetBackDrillParametersLayerValue(layer, offset, val, True)
+        (
+            flag,
+            drill_to_layer,
+            offset,
+            diameter,
+        ) = self._edb_padstackinstance.GetBackDrillParametersLayerValue(layer, offset, val, True)
         if flag:
             if offset.ToDouble():
                 return drill_to_layer.GetName(), diameter.ToString(), offset.ToString()
@@ -1503,9 +1493,9 @@ class EDBPadstackInstance(Primitive):
         val = self._pedb.edb_value(drill_diameter)
         offset = self._pedb.edb_value(offset)
         if offset.ToDouble():
-            return self._edb_padstackinstance.SetBackDrillParameters(layer, offset, val, True)
+            return self._edb_object.SetBackDrillParameters(layer, offset, val, True)
         else:
-            return self._edb_padstackinstance.SetBackDrillParameters(layer, val, True)
+            return self._edb_object.SetBackDrillParameters(layer, val, True)
 
     @property
     def start_layer(self):
@@ -1517,7 +1507,7 @@ class EDBPadstackInstance(Primitive):
             Name of the starting layer.
         """
         layer = self._pedb.edb_api.cell.layer("", self._pedb.edb_api.cell.layer_type.SignalLayer)
-        _, start_layer, stop_layer = self._edb_padstackinstance.GetLayerRange()
+        _, start_layer, stop_layer = self._edb_object.GetLayerRange()
 
         if start_layer:
             return start_layer.GetName()
@@ -1751,12 +1741,9 @@ class EDBPadstackInstance(Primitive):
         >>> edbapp.padstacks.instances[111].get_aedt_pin_name()
 
         """
-        if is_ironpython:
-            name = _clr.Reference[String]()
-            self._edb_padstackinstance.GetProductProperty(self._pedb.edb_api.ProductId.Designer, 11, name)
-        else:
-            val = String("")
-            _, name = self._edb_padstackinstance.GetProductProperty(self._pedb.edb_api.ProductId.Designer, 11, val)
+
+        val = String("")
+        _, name = self._edb_padstackinstance.GetProductProperty(self._pedb.edb_api.ProductId.Designer, 11, val)
         name = str(name).strip("'")
         return name
 

pyedb/dotnet/edb_core/general.py

@@ -30,15 +30,12 @@ from __future__ import absolute_import  # noreorder
 import logging
 
 from pyedb.dotnet.clr_module import Dictionary, List, Tuple
-from pyedb.generic.general_methods import is_ironpython
-
-if not is_ironpython:  # pragma: no cover
-    try:
-        from enum import Enum
-    except ImportError:
-        Enum = None
-else:  # pragma: no cover
-    Enum = object
+
+try:
+    from enum import Enum
+except ImportError:
+    Enum = None
+
 
 logger = logging.getLogger(__name__)
 

pyedb/dotnet/edb_core/hfss.py

@@ -36,7 +36,7 @@ from pyedb.dotnet.edb_core.general import (
     convert_pytuple_to_nettuple,
 )
 from pyedb.generic.constants import RadiationBoxType, SweepType
-from pyedb.generic.general_methods import generate_unique_name, is_ironpython
+from pyedb.generic.general_methods import generate_unique_name
 from pyedb.modeler.geometry_operators import GeometryOperators
 
 
@@ -1258,13 +1258,9 @@ class EdbHfss(object):
             adapt.AdaptiveFrequency = simulation_setup.mesh_freq
             adapt.MaxPasses = int(simulation_setup.max_num_passes)
             adapt.MaxDelta = str(simulation_setup.max_mag_delta_s)
-            if is_ironpython:
-                simsetup_info.SimulationSettings.AdaptiveSettings.AdaptiveFrequencyDataList.Clear()
-                simsetup_info.SimulationSettings.AdaptiveSettings.AdaptiveFrequencyDataList.Add(adapt)
-            else:
-                simsetup_info.SimulationSettings.AdaptiveSettings.AdaptiveFrequencyDataList = (
-                    convert_py_list_to_net_list([adapt])
-                )
+            simsetup_info.SimulationSettings.AdaptiveSettings.AdaptiveFrequencyDataList = convert_py_list_to_net_list(
+                [adapt]
+            )
         elif simulation_setup.ac_settings.adaptive_type == 2:
             low_freq_adapt_data = self._pedb.simsetupdata.AdaptiveFrequencyData()
             low_freq_adapt_data.MaxDelta = str(simulation_setup.max_mag_delta_s)

pyedb/dotnet/edb_core/layout_obj_instance.py

@@ -0,0 +1,30 @@
+# Copyright (C) 2023 - 2024 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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.
+
+from pyedb.dotnet.edb_core.utilities.obj_base import ObjBase
+
+
+class LayoutObjInstance(ObjBase):
+    """Manages EDB functionalities for the layout object instance."""
+
+    def __init__(self, pedb, edb_object):
+        super().__init__(pedb, edb_object)

pyedb/dotnet/edb_core/materials.py

@@ -32,10 +32,8 @@ import warnings
 from pydantic import BaseModel, confloat
 
 from pyedb import Edb
-from pyedb.dotnet.clr_module import _clr
 from pyedb.dotnet.edb_core.general import convert_py_list_to_net_list
 from pyedb.exceptions import MaterialModelException
-from pyedb.generic.general_methods import is_ironpython
 
 logger = logging.getLogger(__name__)
 
@@ -426,16 +424,11 @@ class Material(object):
 
     def __property_value(self, material_property_id):
         """Get property value from a material property id."""
-        if is_ironpython:  # pragma: no cover
-            property_box = _clr.StrongBox[float]()
-            self.__material_def.GetProperty(material_property_id, property_box)
-            return float(property_box)
+        _, property_box = self.__material_def.GetProperty(material_property_id)
+        if isinstance(property_box, float):
+            return property_box
         else:
-            _, property_box = self.__material_def.GetProperty(material_property_id)
-            if isinstance(property_box, float):
-                return property_box
-            else:
-                return property_box.ToDouble()
+            return property_box.ToDouble()
 
     # def __reset_property(self, name):
     #     """Reset a property using the default value of the EDB API.

pyedb/dotnet/edb_core/{layout.py → modeler.py}

@@ -26,6 +26,7 @@ This module contains these classes: `EdbLayout` and `Shape`.
 import math
 import warnings
 
+from pyedb.dotnet.edb_core.cell.primitive import Bondwire
 from pyedb.dotnet.edb_core.dotnet.primitive import (
     CircleDotNet,
     PathDotNet,
@@ -37,7 +38,7 @@ from pyedb.dotnet.edb_core.edb_data.utilities import EDBStatistics
 from pyedb.dotnet.edb_core.general import convert_py_list_to_net_list
 
 
-class EdbLayout(object):
+class Modeler(object):
     """Manages EDB methods for primitives management accessible from `Edb.modeler` property.
 
     Examples
@@ -47,8 +48,31 @@ class EdbLayout(object):
     >>> edb_layout = edbapp.modeler
     """
 
+    def __getitem__(self, name):
+        """Get  a layout instance from the Edb project.
+
+        Parameters
+        ----------
+        name : str, int
+
+        Returns
+        -------
+        :class:`pyedb.dotnet.edb_core.cell.hierarchy.component.EDBComponent`
+
+        """
+        for i in self.primitives:
+            if (
+                (isinstance(name, str) and i.aedt_name == name)
+                or (isinstance(name, str) and i.aedt_name == name.replace("__", "_"))
+                or (isinstance(name, int) and i.id == name)
+            ):
+                return i
+        self._pedb.logger.error("Primitive not found.")
+        return
+
     def __init__(self, p_edb):
         self._pedb = p_edb
+        self._primitives = []
 
     @property
     def _edb(self):
@@ -124,11 +148,13 @@ class EdbLayout(object):
         list of :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.EDBPrimitives`
             List of primitives.
         """
-        _prims = []
+        if len(self._primitives) == len(self._layout.primitives):
+            return self._primitives
+        self._primitives = []
         if self._active_layout:
             for lay_obj in self._layout.primitives:
-                _prims.append(cast(lay_obj, self._pedb))
-        return _prims
+                self._primitives.append(cast(lay_obj, self._pedb))
+        return self._primitives
 
     @property
     def polygons_by_layer(self):
@@ -643,7 +669,7 @@ class EdbLayout(object):
                 new_points = self._edb.Geometry.PointData(pdata_0, pdata_1)
                 polygonData.SetPoint(idx, new_points)
 
-        elif isinstance(main_shape, EdbLayout.Shape):
+        elif isinstance(main_shape, Modeler.Shape):
             polygonData = self.shape_to_polygon_data(main_shape)
         else:
             polygonData = main_shape
@@ -654,7 +680,7 @@ class EdbLayout(object):
             if isinstance(void, list):
                 void = self.Shape("polygon", points=void)
                 voidPolygonData = self.shape_to_polygon_data(void)
-            elif isinstance(void, EdbLayout.Shape):
+            elif isinstance(void, Modeler.Shape):
                 voidPolygonData = self.shape_to_polygon_data(void)
             else:
                 voidPolygonData = void
@@ -932,7 +958,7 @@ class EdbLayout(object):
 
         Parameters
         ----------
-        shape : :class:`pyedb.dotnet.edb_core.layout.EdbLayout.Shape`
+        shape : :class:`pyedb.dotnet.edb_core.modeler.Modeler.Shape`
             Type of the shape to convert. Options are ``"rectangle"`` and ``"polygon"``.
         """
         if shape.type == "polygon":
@@ -1328,3 +1354,123 @@ class EdbLayout(object):
                             stat_model.occupying_surface[layer] = surface
                             stat_model.occupying_ratio[layer] = surface / outline_surface
         return stat_model
+
+    def create_bondwire(
+        self,
+        definition_name,
+        placement_layer,
+        width,
+        material,
+        start_layer_name,
+        start_x,
+        start_y,
+        end_layer_name,
+        end_x,
+        end_y,
+        net,
+        bondwire_type="jedec4",
+    ):
+        """Create a bondwire object.
+
+        Parameters
+        ----------
+        bondwire_type : :class:`BondwireType`
+            Type of bondwire: kAPDBondWire or kJDECBondWire types.
+        definition_name : str
+            Bondwire definition name.
+        placement_layer : str
+            Layer name this bondwire will be on.
+        width : :class:`Value <ansys.edb.utility.Value>`
+            Bondwire width.
+        material : str
+            Bondwire material name.
+        start_layer_name : str
+            Name of start layer.
+        start_x : :class:`Value <ansys.edb.utility.Value>`
+            X value of start point.
+        start_y : :class:`Value <ansys.edb.utility.Value>`
+            Y value of start point.
+        end_layer_name : str
+            Name of end layer.
+        end_x : :class:`Value <ansys.edb.utility.Value>`
+            X value of end point.
+        end_y : :class:`Value <ansys.edb.utility.Value>`
+            Y value of end point.
+        net : str or :class:`Net <ansys.edb.net.Net>` or None
+            Net of the Bondwire.
+
+        Returns
+        -------
+        :class:`pyedb.dotnet.edb_core.dotnet.primitive.BondwireDotNet`
+            Bondwire object created.
+        """
+
+        return Bondwire(
+            pedb=self._pedb,
+            bondwire_type=bondwire_type,
+            definition_name=definition_name,
+            placement_layer=placement_layer,
+            width=self._pedb.edb_value(width),
+            material=material,
+            start_layer_name=start_layer_name,
+            start_x=self._pedb.edb_value(start_x),
+            start_y=self._pedb.edb_value(start_y),
+            end_layer_name=end_layer_name,
+            end_x=self._pedb.edb_value(end_x),
+            end_y=self._pedb.edb_value(end_y),
+            net=self._pedb.nets[net]._edb_object,
+        )
+
+    def create_pin_group(
+        self,
+        name: str,
+        pins_by_id: list[int] = None,
+        pins_by_aedt_name: list[str] = None,
+        pins_by_name: list[str] = None,
+    ):
+        """Create a PinGroup.
+
+        Parameters
+        name : str,
+            Name of the PinGroup.
+        pins_by_id : list[int] or None
+            List of pins by ID.
+        pins_by_aedt_name : list[str] or None
+            List of pins by AEDT name.
+        pins_by_name : list[str] or None
+            List of pins by name.
+        """
+        pins = {}
+        if pins_by_id:
+            for p in pins_by_id:
+                edb_pin = self._pedb.layout.find_object_by_id(p)
+                if edb_pin and not p in pins:
+                    pins[p] = edb_pin._edb_object
+        if not pins_by_aedt_name:
+            pins_by_aedt_name = []
+        if not pins_by_name:
+            pins_by_name = []
+        if pins_by_aedt_name or pins_by_name:
+            p_inst = self._pedb.layout.padstack_instances
+            _pins = {
+                pin.id: pin._edb_object
+                for pin in p_inst
+                if pin.aedt_name in pins_by_aedt_name or pin.name in pins_by_name
+            }
+            if not pins:
+                pins = _pins
+            else:
+                for id, pin in _pins.items():
+                    if not id in pins:
+                        pins[id] = pin
+        if not pins:
+            self._logger.error("No pin found.")
+            return False
+        pins = list(pins.values())
+        obj = self._edb.cell.hierarchy.pin_group.Create(
+            self._pedb.active_layout, name, convert_py_list_to_net_list(pins)
+        )
+        if obj.IsNull():
+            self._logger.debug("Pin group creation returned Null obj.")
+            return False
+        return self._pedb.siwave.pin_groups[name]