pyedb 0.36.0__py3-none-any.whl → 0.38.0__py3-none-any.whl

pyedb/configuration/cfg_ports_sources.py

@@ -19,6 +19,9 @@
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
+import os
+
+import numpy as np
 
 from pyedb.configuration.cfg_common import CfgBase
 from pyedb.dotnet.edb_core.edb_data.ports import WavePort
@@ -33,6 +36,9 @@ class CfgTerminalInfo(CfgBase):
         self._pedb = pedb
         self.type = list(kwargs.keys())[0]
         self.value = kwargs[self.type]
+        self.contact_type = kwargs.get("contact_type", "default")  # options are full, center, quad, inline
+        self.contact_radius = self._pedb.edb_value(kwargs.get("contact_radius", "0.1mm")).ToDouble()
+        self.num_of_contact = kwargs.get("num_of_contact", 4)
 
     def export_properties(self):
         return {self.type: self.value}
@@ -46,7 +52,6 @@ class CfgCoordianteTerminalInfo(CfgTerminalInfo):
         self.point_x = self.value["point"][0]
         self.point_y = self.value["point"][1]
         self.net = self.value["net"]
-        self.contact_radius = self.value.get("contact_radius", None)
 
     def export_properties(self):
         return {"coordinates": {"layer": self.layer, "point": [self.point_x, self.point_y], "net": self.net}}
@@ -206,6 +211,16 @@ class CfgPorts:
         return ports
 
 
+class CfgProbes:
+    def __init__(self, pedb, data):
+        self._pedb = pedb
+        self.probes = [CfgProbe(self._pedb, **probe) for probe in data]
+
+    def apply(self):
+        for probe in self.probes:
+            probe.api.set_parameters_to_edb()
+
+
 class CfgCircuitElement(CfgBase):
     def __init__(self, pedb, **kwargs):
         self._pedb = pedb
@@ -213,6 +228,7 @@ class CfgCircuitElement(CfgBase):
         self.type = kwargs["type"]
         self.reference_designator = kwargs.get("reference_designator", None)
         self.distributed = kwargs.get("distributed", False)
+        self._elem_num = 1
 
         pos = kwargs["positive_terminal"]  # {"pin" : "A1"}
         if list(pos.keys())[0] == "coordinates":
@@ -230,9 +246,10 @@ class CfgCircuitElement(CfgBase):
         else:
             self.negative_terminal_info = CfgTerminalInfo(self._pedb, **neg)
 
-    def _create_terminals(self):
+    def create_terminals(self):
         """Create step 1. Collect positive and negative terminals."""
 
+        # Collect all positive terminals
         pos_type, pos_value = self.positive_terminal_info.type, self.positive_terminal_info.value
         pos_objs = dict()
         pos_coor_terminal = dict()
@@ -245,35 +262,58 @@ class CfgCircuitElement(CfgBase):
             point = [self.positive_terminal_info.point_x, self.positive_terminal_info.point_y]
             net_name = self.positive_terminal_info.net
             pos_coor_terminal[self.name] = self._pedb.get_point_terminal(self.name, net_name, point, layer)
-            if self.positive_terminal_info.contact_radius:
-                pos_coor_terminal[self.name].contact_radius = self.positive_terminal_info.contact_radius
 
+        elif pos_type == "pin":
+            pins = {pos_value: self._pedb.components.instances[self.reference_designator].pins[pos_value]}
+            if self.positive_terminal_info.contact_type in ["quad", "inline"]:
+                for _, pin in pins.items():
+                    contact_type = self.positive_terminal_info.contact_type
+                    radius = self.positive_terminal_info.contact_radius
+                    num_of_contact = self.positive_terminal_info.num_of_contact
+                    virtual_pins = self._create_virtual_pins_on_pin(pin, contact_type, radius, num_of_contact)
+                    pos_objs.update(virtual_pins)
+                    self._elem_num = len(pos_objs)
+            else:
+                pos_objs.update(pins)
         elif pos_type == "pin_group":
+            pins = self._get_pins(pos_type, pos_value)
             if self.distributed:
-                pins = self._get_pins(pos_type, pos_value)
                 pos_objs.update(pins)
                 self._elem_num = len(pos_objs)
+            elif self.positive_terminal_info.contact_type in ["quad", "inline"]:
+                for _, pin in pins.items():
+                    contact_type = self.positive_terminal_info.contact_type
+                    radius = self.positive_terminal_info.contact_radius
+                    num_of_contact = self.positive_terminal_info.num_of_contact
+                    virtual_pins = self._create_virtual_pins_on_pin(pin, contact_type, radius, num_of_contact)
+                    pos_objs.update(virtual_pins)
+                    self._elem_num = len(pos_objs)
             else:
                 pos_objs[pos_value] = self._pedb.siwave.pin_groups[pos_value]
         elif pos_type == "net":
+            pins = self._get_pins(pos_type, pos_value)
             if self.distributed:
-                pins = self._get_pins(pos_type, pos_value)
                 pos_objs.update(pins)
                 self._elem_num = len(pos_objs)
+            elif self.positive_terminal_info.contact_type in ["quad", "inline"]:
+                for _, pin in pins.items():
+                    contact_type = self.positive_terminal_info.contact_type
+                    radius = self.positive_terminal_info.contact_radius
+                    num_of_contact = self.positive_terminal_info.num_of_contact
+                    virtual_pins = self._create_virtual_pins_on_pin(pin, contact_type, radius, num_of_contact)
+                    pos_objs.update(virtual_pins)
+                    self._elem_num = len(pos_objs)
             else:
-                pins = self._get_pins(pos_type, pos_value)
                 # create pin group
                 neg_obj = self._create_pin_group(pins)
                 pos_objs.update(neg_obj)
-        elif pos_type == "pin":
-            pins = {pos_value: self._pedb.components.instances[self.reference_designator].pins[pos_value]}
-            pos_objs.update(pins)
         else:
             raise Exception(f"Wrong positive terminal type {pos_type}.")
 
         self.pos_terminals = {i: j.create_terminal(i) for i, j in pos_objs.items()}
         self.pos_terminals.update(pos_coor_terminal)
 
+        # Collect all negative terminals
         self.neg_terminal = None
         if self.negative_terminal_info:
             neg_type, neg_value = self.negative_terminal_info.type, self.negative_terminal_info.value
@@ -330,6 +370,66 @@ class CfgCircuitElement(CfgBase):
             pins.update({f"{self.reference_designator}_{terminal_value[0]}_{i}": j for i, j in temp.items()})
         return pins
 
+    def _create_virtual_pins_on_pin(self, pin, contact_type, radius, num_of_contact=4):
+        component = pin.component
+        placement_layer = component.placement_layer
+        pos_x, pos_y = pin.position
+        comp_rotation = self._pedb.edb_value(component.rotation).ToDouble() % 3.141592653589793
+
+        pad = pin.definition.pad_by_layer[placement_layer]
+        if pad.shape.lower() in ["rectangle", "oval"]:
+            width, height = pad.parameters_values[0:2]
+        elif pad.shape.lower() == "nogeometry":
+            polygon_data = pad.polygon_data
+            if polygon_data:
+                p1, p2 = polygon_data.bounding_box
+                width = p2[0] - p1[0]
+                height = p2[1] - p1[1]
+            else:
+                raise AttributeError(f"Unsupported pad shape {pad.shape.lower()}")
+        else:  # pragma no cover
+            raise AttributeError(f"Unsupported pad shape {pad.shape.lower()}")
+
+        positions = []
+        if contact_type.lower() == "inline":
+            if width > height:
+                offset = (width - radius * 2) / (num_of_contact - 1)
+            else:
+                offset = (height - radius * 2) / (num_of_contact - 1)
+
+            start_pos = (num_of_contact - 1) / 2
+            offset = [offset * i for i in np.arange(start_pos * -1, start_pos + 1)]
+
+            if (width > height and comp_rotation == 0) or (width < height and comp_rotation != 0):
+                positions.extend(list(zip(offset, [0] * num_of_contact)))
+            else:
+                positions.extend(list(zip([0] * num_of_contact, offset)))
+        else:  # quad
+            x_offset = width / 2 - radius if comp_rotation == 0 else height / 2 - radius
+            y_offset = height / 2 - radius if comp_rotation == 0 else width / 2 - radius
+
+            for x, y in [[1, 1], [-1, 1], [1, -1], [-1, -1]]:
+                positions.append([x_offset * x, y_offset * y])
+
+        pdef_name = f"{self.name}_{pin.pin_number}"
+        self._pedb.padstacks.create(padstackname=pdef_name, has_hole=False, paddiam=radius * 2, antipaddiam=0)
+        instances = {}
+        for idx, xy in enumerate(positions):
+            x = xy[0] + pos_x
+            y = xy[1] + pos_y
+            pin_name = f"{pdef_name}_{idx}"
+            p_inst = self._pedb.padstacks.place(
+                position=[x, y],
+                definition_name=pdef_name,
+                net_name=pin.net_name,
+                via_name=pin_name,
+                fromlayer=placement_layer,
+                tolayer=placement_layer,
+                is_pin=True,
+            )
+            instances[pin_name] = p_inst
+        return instances
+
     def _create_pin_group(self, pins, is_ref=False):
         if is_ref:
             pg_name = f"pg_{self.name}_{self.reference_designator}_ref"
@@ -350,7 +450,7 @@ class CfgPort(CfgCircuitElement):
 
     def set_parameters_to_edb(self):
         """Create port."""
-        self._create_terminals()
+        self.create_terminals()
         is_circuit_port = True if self.type == "circuit" else False
         circuit_elements = []
         for name, j in self.pos_terminals.items():
@@ -382,52 +482,66 @@ class CfgSource(CfgCircuitElement):
         super().__init__(pedb, **kwargs)
 
         self.magnitude = kwargs.get("magnitude", 0.001)
-        self.equipotential = kwargs.get("equipotential", False)
 
     def set_parameters_to_edb(self):
         """Create sources."""
-        self._create_terminals()
+        self.create_terminals()
         # is_circuit_port = True if self.type == "circuit" else False
         circuit_elements = []
-        method = self._pedb.create_current_source if self.type == "current" else self._pedb.create_voltage_source
+        create_xxx_source = (
+            self._pedb.create_current_source if self.type == "current" else self._pedb.create_voltage_source
+        )
         for name, j in self.pos_terminals.items():
             if isinstance(self.neg_terminal, dict):
-                elem = method(j, self.neg_terminal[name])
+                elem = create_xxx_source(j, self.neg_terminal[name])
             else:
-                elem = method(j, self.neg_terminal)
-            if not self.distributed:
+                elem = create_xxx_source(j, self.neg_terminal)
+            if self._elem_num == 1:
                 elem.name = self.name
                 elem.magnitude = self.magnitude
             else:
-                elem.name = f"{self.name}_{elem.name}"
+                elem.name = name
                 elem.magnitude = self.magnitude / self._elem_num
+            elem = self._pedb.terminals[elem.name]
             circuit_elements.append(elem)
-        for terminal in circuit_elements:
-            if self.equipotential:
-                terms = [terminal, terminal.ref_terminal] if terminal.ref_terminal else [terminal]
-                for t in terms:
-                    pads = []
-                    if t.terminal_type == "PadstackInstanceTerminal":
-                        pads.append(t.reference_object)
-                        t._edb_object.dcir_equipotential_region = True
-                    elif t.terminal_type == "PinGroupTerminal":
-                        name = t._edb_object.GetPinGroup().GetName()
-                        pg = self._pedb.siwave.pin_groups[name]
-                        pads.extend([i for _, i in pg.pins.items()])
-                    elif t.terminal_type == "PointTerminal":
-                        temp = [i for i in self._pedb.layout.terminals if i.name == t.name][0]
-                        if not temp.is_reference_terminal:
-                            radius = self.positive_terminal_info.contact_radius
-                        else:
-                            radius = self.negative_terminal_info.contact_radius
-                        if radius is not None:
-                            prim = self._pedb.modeler.create_circle(
-                                temp.layer.name, temp.location[0], temp.location[1], radius, temp.net_name
-                            )
-                            prim.dcir_equipotential_region = True
 
+        for terminal in circuit_elements:
+            # Get reference terminal
+            terms = [terminal, terminal.ref_terminal] if terminal.ref_terminal else [terminal]
+            for t in terms:
+                if not t.is_reference_terminal:
+                    radius = self.positive_terminal_info.contact_radius
+                    contact_type = self.positive_terminal_info.contact_type
+                else:
+                    radius = self.negative_terminal_info.contact_radius
+                    contact_type = self.negative_terminal_info.contact_type
+                if t.terminal_type == "PointTerminal":
+                    temp = [i for i in self._pedb.layout.terminals if i.name == t.name][0]
+                    prim = self._pedb.modeler.create_circle(
+                        temp.layer.name, temp.location[0], temp.location[1], radius, temp.net_name
+                    )
+                    prim.dcir_equipotential_region = True
+                    continue
+                elif contact_type.lower() == "default":
+                    continue
+                elif t.terminal_type == "PadstackInstanceTerminal":
+                    if contact_type.lower() in ["full", "quad", "inline"]:
+                        t.padstack_instance._set_equipotential()
+                    elif contact_type.lower() == "center":
+                        t.padstack_instance._set_equipotential(contact_radius=radius)
+                elif t.terminal_type == "PinGroupTerminal":
+                    name = t._edb_object.GetPinGroup().GetName()
+                    pg = self._pedb.siwave.pin_groups[name]
+                    pads = [i for _, i in pg.pins.items()]
                     for i in pads:
-                        i._set_equipotential()
+                        if contact_type.lower() in ["full", "quad", "inline"]:
+                            i._set_equipotential()
+                        elif contact_type.lower() == "center":
+                            i._set_equipotential(contact_radius=radius)
+                        elif t.is_reference_terminal:
+                            continue
+                else:
+                    raise AttributeError("Unsupported terminal type.")
 
         return circuit_elements
 
@@ -442,6 +556,41 @@ class CfgSource(CfgCircuitElement):
         }
 
 
+class CfgProbe(CfgCircuitElement):
+    class Common:
+        def __init__(self, parent):
+            self.parent = parent
+            self.pedb = parent._pedb
+
+        def set_parameters_to_edb(self):
+            self.parent.create_terminals()
+            circuit_elements = []
+            for name, j in self.parent.pos_terminals.items():
+                if isinstance(self.parent.neg_terminal, dict):
+                    elem = self.pedb.create_voltage_probe(j, self.parent.neg_terminal[name])
+                else:
+                    elem = self.pedb.create_voltage_probe(j, self.parent.neg_terminal)
+                elem.name = self.parent.name
+                circuit_elements.append(elem)
+            return circuit_elements
+
+    class Grpc(Common):
+        def __init__(self, parent):
+            super().__init__(parent)
+
+    class DotNet(Grpc):
+        def __init__(self, parent):
+            super().__init__(parent)
+
+    def __init__(self, pedb, **kwargs):
+        kwargs["type"] = "probe"
+        super().__init__(pedb, **kwargs)
+        if os.environ["PYEDB_USE_DOTNET"] == "0":
+            self.api = self.Grpc(self)
+        else:
+            self.api = self.DotNet(self)
+
+
 class CfgWavePort:
     def __init__(self, pedb, **kwargs):
         self._pedb = pedb

pyedb/configuration/configuration.py

@@ -140,11 +140,11 @@ class Configuration:
             temp = []
             for _, pdef in pedb_defs.items():
                 cfg_def = CfgPadstackDefinition(self._pedb, pdef)
-                cfg_def.retrieve_parameters_from_edb()
+                cfg_def.api.retrieve_parameters_from_edb()
                 temp.append(cfg_def)
             self.cfg_data.stackup.apply()
             for cfg_pdef in temp:
-                cfg_pdef.set_parameters_to_edb()
+                cfg_pdef.api.set_parameters_to_edb()
         else:
             self.cfg_data.stackup.apply()
 
@@ -171,6 +171,9 @@ class Configuration:
         # Configure ports
         self.cfg_data.ports.apply()
 
+        # Configure probes
+        self.cfg_data.probes.apply()
+
         return True
 
     def _load_stackup(self):

pyedb/dotnet/edb.py

@@ -4106,7 +4106,7 @@ class Edb(Database):
         term.boundary_type = "kVoltageSource"
 
         ref_term = Terminal(self, ref_terminal._edb_object)
-        ref_term.boundary_type = "kVoltageProbe"
+        ref_term.boundary_type = "kVoltageSource"
 
         term.ref_terminal = ref_terminal
         return self.sources[term.name]

pyedb/dotnet/edb_core/cell/layout.py

@@ -66,7 +66,7 @@ def primitive_cast(pedb, edb_object):
     elif edb_object.GetPrimitiveType().ToString() == "Bondwire":
         return Bondwire(pedb, edb_object)
     elif edb_object.GetPrimitiveType().ToString() == "Text":
-        return EdbText(edb_object, pedb)
+        return EdbText(pedb, edb_object)
     elif edb_object.GetPrimitiveType().ToString() == "PrimitivePlugin":
         return
     elif edb_object.GetPrimitiveType().ToString() == "Path3D":
@@ -152,7 +152,7 @@ class Layout(ObjBase):
         is_pins : bool, optional
             True for pins, false for vias (default).
         """
-        self._edb_object.ConvertPrimitivesToVias(convert_py_list_to_net_list(primitives), is_pins)
+        self._edb_object.ConvertPrimitivestoVias(convert_py_list_to_net_list(primitives), is_pins)
 
     @property
     def zone_primitives(self):
@@ -220,7 +220,7 @@ class Layout(ObjBase):
         -------
         """
 
-        return [EDBNetsData(net, self._pedb) for net in self._edb_object.Nets]
+        return [EDBNetsData(net, self._pedb) for net in self._edb_object.Nets if net]
 
     @property
     def primitives(self):
@@ -230,7 +230,7 @@ class Layout(ObjBase):
         -------
         list of :class:`dotnet.edb_core.dotnet.primitive.PrimitiveDotNet` cast objects.
         """
-        return [primitive_cast(self._pedb, p) for p in self._edb_object.Primitives]
+        return [primitive_cast(self._pedb, p) for p in self._edb_object.Primitives if p]
 
     @property
     def bondwires(self):
@@ -331,16 +331,32 @@ class Layout(ObjBase):
         obj = self._pedb._edb.Cell.Hierarchy.Component.FindByName(self._edb_object, value)
         return EDBComponent(self._pedb, obj) if obj is not None else None
 
-    def find_primitive(self, layer_name: Union[str, list]) -> list:
+    def find_primitive(
+        self, layer_name: Union[str, list] = None, name: Union[str, list] = None, net_name: Union[str, list] = None
+    ) -> list:
         """Find a primitive objects by layer name.
 
         Parameters
         ----------
-        layer_name : str, list
+        layer_name : str, list, optional
             Name of the layer.
+        name : str, list, optional
+            Name of the primitive
+        net_name : str, list, optional
+            Name of the primitive
         Returns
         -------
         list
         """
-        layer_name = layer_name if isinstance(layer_name, list) else [layer_name]
-        return [i for i in self.primitives if i.layer_name in layer_name]
+        if layer_name is not None:
+            layer_name = layer_name if isinstance(layer_name, list) else [layer_name]
+        if name is not None:
+            name = name if isinstance(name, list) else [name]
+        if net_name is not None:
+            net_name = net_name if isinstance(net_name, list) else [net_name]
+
+        prims = self.primitives
+        prims = [i for i in prims if i.aedt_name in name] if name is not None else prims
+        prims = [i for i in prims if i.layer_name in layer_name] if layer_name is not None else prims
+        prims = [i for i in prims if i.net_name in net_name] if net_name is not None else prims
+        return prims

pyedb/dotnet/edb_core/edb_data/nets_data.py

@@ -59,7 +59,7 @@ class EDBNetsData(NetDotNet):
         """
         from pyedb.dotnet.edb_core.cell.layout import primitive_cast
 
-        return [primitive_cast(self._app, i) for i in self.net_object.Primitives]
+        return [primitive_cast(self._app, i) for i in self.net_object.Primitives if i]
         # return [self._app.layout.find_object_by_id(i.GetId()) for i in self.net_object.Primitives]
 
     @property

pyedb/dotnet/edb_core/edb_data/padstacks_data.py

@@ -34,6 +34,7 @@ from pyedb.dotnet.edb_core.general import (
     pascal_to_snake,
     snake_to_pascal,
 )
+from pyedb.dotnet.edb_core.geometry.polygon_data import PolygonData
 from pyedb.generic.general_methods import generate_unique_name
 from pyedb.modeler.geometry_operators import GeometryOperators
 
@@ -155,6 +156,24 @@ class EDBPadProperties(object):
     def polygon_data(self):
         """Parameters.
 
+        Returns
+        -------
+        list
+            List of parameters.
+        """
+
+        flag, edb_object, _, _, _ = self._edb_padstack.GetData().GetPolygonalPadParameters(
+            self.layer_name, self.int_to_pad_type(self.pad_type)
+        )
+        if flag:
+            return PolygonData(self._edb._app, edb_object)
+        else:  # pragma no cover
+            raise AttributeError("No polygon data.")
+
+    @property
+    def _polygon_data_dotnet(self):
+        """Parameters.
+
         Returns
         -------
         list
@@ -780,7 +799,7 @@ class EDBPadstack(object):
         pdef_data.SetHoleRange(getattr(self._edb.definition.PadstackHoleRange, snake_to_pascal(value)))
         self._padstack_def_data = pdef_data
 
-    def convert_to_3d_microvias(self, convert_only_signal_vias=True, hole_wall_angle=15, delete_padstack_def=True):
+    def convert_to_3d_microvias(self, convert_only_signal_vias=True, hole_wall_angle=75, delete_padstack_def=True):
         """Convert actual padstack instance to microvias 3D Objects with a given aspect ratio.
 
         Parameters
@@ -812,22 +831,9 @@ class EDBPadstack(object):
         layer_names = [i for i in list(layers.keys())]
         if convert_only_signal_vias:
             signal_nets = [i for i in list(self._ppadstack._pedb.nets.signal_nets.keys())]
-        topl, topz, bottoml, bottomz = self._ppadstack._pedb.stackup.limits(True)
-        if self.via_start_layer in layers:
-            start_elevation = layers[self.via_start_layer].lower_elevation
-        else:
-            start_elevation = layers[self.instances[0].start_layer].lower_elevation
-        if self.via_stop_layer in layers:
-            stop_elevation = layers[self.via_stop_layer].upper_elevation
-        else:
-            stop_elevation = layers[self.instances[0].stop_layer].upper_elevation
 
-        diel_thick = abs(start_elevation - stop_elevation)
-        rad1 = self.hole_properties[0] / 2 - math.tan(hole_wall_angle * diel_thick * math.pi / 180)
-        rad2 = self.hole_properties[0] / 2
+        layer_count = len(self._ppadstack._pedb.stackup.signal_layers)
 
-        if start_elevation < (topz + bottomz) / 2:
-            rad1, rad2 = rad2, rad1
         i = 0
         for via in list(self.padstack_instances.values()):
             if convert_only_signal_vias and via.net_name in signal_nets or not convert_only_signal_vias:
@@ -863,18 +869,33 @@ class EDBPadstack(object):
                         self._get_edb_value(pos[1]),
                         self._get_edb_value(self.pad_by_layer[self.via_stop_layer].parameters_values[0] / 2),
                     )
-                for layer_name in layer_names:
+                for layer_idx, layer_name in enumerate(layer_names):
                     stop = ""
                     if layer_name == via.start_layer or started:
                         start = layer_name
                         stop = layer_names[layer_names.index(layer_name) + 1]
+
+                        start_elevation = layers[start].lower_elevation
+                        stop_elevation = layers[stop].upper_elevation
+                        diel_thick = abs(start_elevation - stop_elevation)
+
+                        rad_large = self.hole_diameter / 2
+                        rad_small = rad_large - diel_thick * 1 / math.tan(math.radians(hole_wall_angle))
+
+                        if layer_idx + 1 < layer_count / 2:  # upper half of stack
+                            rad_u = rad_large
+                            rad_l = rad_small
+                        else:
+                            rad_u = rad_small
+                            rad_l = rad_large
+
                         cloned_circle = self._edb.cell.primitive.circle.create(
                             layout,
                             start,
                             via._edb_padstackinstance.GetNet(),
                             self._get_edb_value(pos[0]),
                             self._get_edb_value(pos[1]),
-                            self._get_edb_value(rad1),
+                            self._get_edb_value(rad_u),
                         )
                         cloned_circle2 = self._edb.cell.primitive.circle.create(
                             layout,
@@ -882,7 +903,7 @@ class EDBPadstack(object):
                             via._edb_padstackinstance.GetNet(),
                             self._get_edb_value(pos[0]),
                             self._get_edb_value(pos[1]),
-                            self._get_edb_value(rad2),
+                            self._get_edb_value(rad_l),
                         )
                         s3d = self._edb.cell.hierarchy._hierarchy.Structure3D.Create(
                             layout, generate_unique_name("via3d_" + via.aedt_name.replace("via_", ""), n=3)
@@ -1247,10 +1268,18 @@ class EDBPadstackInstance(Primitive):
 
         return self._pedb.create_port(terminal, ref_terminal, is_circuit_port)
 
-    def _set_equipotential(self):
+    def _set_equipotential(self, contact_radius=None):
         """Workaround solution. Remove when EDBAPI bug is fixed for dcir_equipotential_region."""
         pad = self.definition.pad_by_layer[self.start_layer]
-        if pad.shape.lower() == "circle":
+
+        pos_x, pos_y = self.position
+
+        if contact_radius is not None:
+            prim = self._pedb.modeler.create_circle(pad.layer_name, pos_x, pos_y, contact_radius, self.net_name)
+            prim.dcir_equipotential_region = True
+            return
+
+        elif pad.shape.lower() == "circle":
             ra = self._pedb.edb_value(pad.parameters_values[0] / 2)
             pos = self.position
             prim = self._pedb.modeler.create_circle(pad.layer_name, pos[0], pos[1], ra, self.net_name)
@@ -1265,9 +1294,16 @@ class EDBPadstackInstance(Primitive):
                 center_point=self.position,
                 rotation=self.component.rotation,
             )
-
+        elif pad.shape.lower() == "oval":
+            width, height, _ = pad.parameters_values
+            prim = self._pedb.modeler.create_circle(
+                pad.layer_name, self.position[0], self.position[1], height / 2, self.net_name
+            )
         elif pad.polygon_data:
-            prim = self._pedb.modeler.create_polygon(pad.polygon_data, self.start_layer, net_name=self.net_name)
+            prim = self._pedb.modeler.create_polygon(
+                pad.polygon_data._edb_object, self.start_layer, net_name=self.net_name
+            )
+            prim.move(self.position)
         else:
             return
         prim.dcir_equipotential_region = True
@@ -1579,7 +1615,7 @@ class EDBPadstackInstance(Primitive):
         layer_list = []
         start_layer_name = start_layer.GetName()
         stop_layer_name = stop_layer.GetName()
-        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:
@@ -1921,7 +1957,7 @@ class EDBPadstackInstance(Primitive):
 
         pad_shape = padstack_pad.geometry_type
         params = padstack_pad.parameters_values
-        polygon_data = padstack_pad.polygon_data
+        polygon_data = padstack_pad._polygon_data_dotnet
 
         def _rotate(p):
             x = p[0] * math.cos(rotation) - p[1] * math.sin(rotation)
@@ -2038,8 +2074,8 @@ class EDBPadstackInstance(Primitive):
             # Polygon
             points = []
             i = 0
-            while i < polygon_data.edb_api.Count:
-                point = polygon_data.edb_api.GetPoint(i)
+            while i < polygon_data._edb_object.Count:
+                point = polygon_data._edb_object.GetPoint(i)
                 i += 1
                 if point.IsArc():
                     continue

pyedb/dotnet/edb_core/geometry/polygon_data.py

@@ -19,6 +19,7 @@
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
+from typing import Union
 
 from pyedb.dotnet.edb_core.general import convert_py_list_to_net_list
 from pyedb.dotnet.edb_core.geometry.point_data import PointData
@@ -128,3 +129,7 @@ class PolygonData:
             arcs = convert_py_list_to_net_list(arcs)
         poly = self._edb_object.CreateFromArcs(arcs, flag)
         return PolygonData(self._pedb, poly)
+
+    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))

pyedb/dotnet/edb_core/modeler.py

@@ -661,8 +661,7 @@ class Modeler(object):
         else:
             polygonData = main_shape
         if not polygonData or polygonData.IsNull():
-            self._logger.error("Failed to create main shape polygon data")
-            return False
+            raise RuntimeError("Failed to create main shape polygon data")
         for void in voids:
             if isinstance(void, list):
                 void = self.Shape("polygon", points=void)