pyedb 0.37.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,9 +36,9 @@ class CfgTerminalInfo(CfgBase):
         self._pedb = pedb
         self.type = list(kwargs.keys())[0]
         self.value = kwargs[self.type]
-        self.contact_radius = kwargs.get("contact_radius", None)
-        self.num_of_contact = kwargs.get("num_of_contact", 1)
-        self.inline = kwargs.get("inline", False)
+        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}
@@ -208,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
@@ -215,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":
@@ -232,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()
@@ -248,32 +263,57 @@ class CfgCircuitElement(CfgBase):
             net_name = self.positive_terminal_info.net
             pos_coor_terminal[self.name] = self._pedb.get_point_terminal(self.name, net_name, point, layer)
 
+        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,56 +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:
-                    if not t.is_reference_terminal:
-                        radius = self.positive_terminal_info.contact_radius
-                        num_of_contact = self.positive_terminal_info.num_of_contact
-                        inline = self.positive_terminal_info.inline
-                    else:
-                        radius = self.negative_terminal_info.contact_radius
-                        num_of_contact = self.negative_terminal_info.num_of_contact
-                        inline = self.negative_terminal_info.inline
-
-                    pads = []
-                    if t.terminal_type == "PadstackInstanceTerminal":
-                        pads.append(t.reference_object)
-                    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" and radius:
-                        temp = [i for i in self._pedb.layout.terminals if i.name == t.name][0]
-                        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(contact_radius=radius, inline=inline, num_of_contact=num_of_contact)
+                        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
 
@@ -446,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):

pyedb/dotnet/edb_core/edb_data/padstacks_data.py

@@ -24,8 +24,6 @@ from collections import OrderedDict
 import math
 import warnings
 
-import numpy as np
-
 from pyedb.dotnet.clr_module import String
 from pyedb.dotnet.edb_core.cell.primitive.primitive import Primitive
 from pyedb.dotnet.edb_core.dotnet.database import PolygonDataDotNet
@@ -36,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
 
@@ -157,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
@@ -782,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
@@ -814,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:
@@ -865,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,
@@ -884,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)
@@ -1249,47 +1268,15 @@ class EDBPadstackInstance(Primitive):
 
         return self._pedb.create_port(terminal, ref_terminal, is_circuit_port)
 
-    def _set_equipotential(self, contact_radius=None, inline=False, num_of_contact=1):
+    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]
 
         pos_x, pos_y = self.position
-        comp_rotation = self._pedb.edb_value(self.component.rotation).ToDouble() % 3.141592653589793
 
         if contact_radius is not None:
-            if num_of_contact == 1:
-                prim = self._pedb.modeler.create_circle(pad.layer_name, pos_x, pos_y, contact_radius, self.net_name)
-                prim.dcir_equipotential_region = True
-            else:
-                if pad.shape.lower() in ["rectangle", "oval"]:
-                    width, height = pad.parameters_values[0:2]
-                    radius = self._pedb.edb_value(contact_radius).ToDouble()
-                else:
-                    return
-
-                if inline is False:
-                    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
-                    positions = []
-                    for x, y in [[1, 1], [-1, 1], [1, -1], [-1, -1]]:
-                        positions.append([x_offset * x, y_offset * y])
-                else:
-                    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 = list(zip(offset, [0] * num_of_contact))
-                    else:
-                        positions = list(zip([0] * num_of_contact, offset))
-
-                for x, y in positions:
-                    prim = self._pedb.modeler.create_circle(pad.layer_name, pos_x + x, pos_y + y, radius, self.net_name)
-                    prim.dcir_equipotential_region = True
+            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":
@@ -1970,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)
@@ -2087,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/padstack.py

@@ -1859,8 +1859,9 @@ class EdbPadstacks(object):
                     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:
-                        self.instances[item].delete()
+                        all_instances[item].delete()
 
                 return True

pyedb/dotnet/edb_core/sim_setup_data/data/settings.py

@@ -149,6 +149,21 @@ class AdaptiveSettings(object):
         self.adaptive_settings.MinPasses = value
         self._parent._update_setup()
 
+    @property
+    def min_converged_passes(self):
+        """Minimum number of converged passes.
+
+        Returns
+        -------
+            int
+        """
+        return self.adaptive_settings.MinConvergedPasses
+
+    @min_converged_passes.setter
+    def min_converged_passes(self, value):
+        self.adaptive_settings.MinConvergedPasses = value
+        self._parent._update_setup()
+
     @property
     def save_fields(self):
         """Whether to turn on save fields.

pyedb/dotnet/edb_core/sim_setup_data/data/sweep_data.py

@@ -160,11 +160,11 @@ class SweepData(object):
     @freq_sweep_type.setter
     def freq_sweep_type(self, value):
         edb_freq_sweep_type = self._edb_object.TFreqSweepType
-        if value in [0, "kInterpolatingSweep"]:
+        if value in [0, "kInterpolatingSweep", "interpolation"]:
             self._edb_object.FreqSweepType = edb_freq_sweep_type.kInterpolatingSweep
-        elif value in [1, "kDiscreteSweep"]:
+        elif value in [1, "kDiscreteSweep", "discrete"]:
             self._edb_object.FreqSweepType = edb_freq_sweep_type.kDiscreteSweep
-        elif value in [2, "kBroadbandFastSweep"]:
+        elif value in [2, "kBroadbandFastSweep", "broadband"]:
             self._edb_object.FreqSweepType = edb_freq_sweep_type.kBroadbandFastSweep
         elif value in [3, "kNumSweepTypes"]:
             self._edb_object.FreqSweepType = edb_freq_sweep_type.kNumSweepTypes

pyedb/dotnet/edb_core/utilities/simulation_setup.py

@@ -265,6 +265,7 @@ class SimulationSetup(object):
         for k, v in kwargs.items():
             if k in dir(sweep_data):
                 setattr(sweep_data, k, v)
+        sweep_data.freq_sweep_type = kwargs.get("sweep_type") if kwargs.get("sweep_type") else "interpolation"
 
         if frequency_set is None:
             sweep_type = "linear_scale"